@pagopa/dx-cli 0.23.2 → 0.23.4

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

@@ -1,23 +1,32 @@
-import { getLogger } from "@logtape/logtape";
 import { Command } from "commander";
-import { exitWithError } from "../index.js";
-export const makeCodemodCommand = ({ applyCodemodById, listCodemods, }) => new Command("codemod")
+import { ResultAsync } from "neverthrow";
+import { asError, reportCommandError } from "../command-errors.js";
+import { createCommandPresenter, resolveOutputMode, } from "../presenters/index.js";
+export const makeCodemodCommand = ({ applyCodemodById, listCodemods }, env) => new Command("codemod")
     .description("Manage and apply migration scripts to the repository")
     .addCommand(new Command("list")
     .description("List available migration scripts")
     .action(async function () {
+    const { output } = this.optsWithGlobals();
+    const outputMode = resolveOutputMode(env, output);
+    const presenter = createCommandPresenter(outputMode);
     await listCodemods()
-        .andTee((codemods) => console.table(codemods, ["id", "description"]))
-        .orTee(exitWithError(this));
+        .map((codemods) => codemods.map(({ description, id }) => ({ description, id })))
+        .andTee((codemods) => presenter.reportResult(codemods))
+        .orTee(reportCommandError(this, presenter, outputMode));
 }))
     .addCommand(new Command("apply")
     .argument("<id>", "The id of the codemod to apply")
     .description("Apply migration scripts to the repository")
     .action(async function (id) {
-    const logger = getLogger(["dx-cli", "codemod"]);
-    await applyCodemodById(id)
-        .andTee(() => {
-        logger.info("Codemod applied ✅");
-    })
-        .orTee(exitWithError(this));
+    const { output } = this.optsWithGlobals();
+    const outputMode = resolveOutputMode(env, output);
+    const presenter = createCommandPresenter(outputMode);
+    await ResultAsync.fromPromise(presenter.trackStep(`Applying codemod ${id}...`, () => applyCodemodById(id).match(() => undefined, (error) => {
+        throw error;
+    })), asError(`Failed to apply codemod ${id}`))
+        .map(() => ({ id }))
+        .andTee((result) => presenter.reportResult(result))
+        .orTee(reportCommandError(this, presenter, outputMode));
 }));
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,4 +1,5 @@
 import { Command } from "commander";
+import type { Dependencies } from "../../../domain/dependencies.js";
+import type { CliEnv } from "../env.js";
 import { Config } from "../../../config.js";
-import { Dependencies } from "../../../domain/dependencies.js";
-export declare const makeDoctorCommand: (dependencies: Dependencies, config: Config) => Command;
+export declare const makeDoctorCommand: (dependencies: Dependencies, config: Config, env: CliEnv) => Command;

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

@@ -1,12 +1,33 @@
+/**
+ * `doctor` Commander command.
+ *
+ * Verifies the repository setup and routes the outcome through the shared
+ * CommandPresenter port. JSON mode emits the structured result; text mode emits
+ * a human-readable per-check summary. The exit code reflects whether any check
+ * failed, mirroring the linter convention (a successful run can still report
+ * problems).
+ */
+import chalk from "chalk";
 import { Command } from "commander";
-import * as process from "node:process";
-import { printDoctorResult, runDoctor } from "../../../domain/doctor.js";
-export const makeDoctorCommand = (dependencies, config) => new Command()
+import { runDoctor } from "../../../domain/doctor.js";
+import { createCommandPresenter, resolveOutputMode, } from "../presenters/index.js";
+const formatCheck = (check) => check.isValid
+    ? chalk.green(`✅ ${check.successMessage}`)
+    : chalk.red(`❌ ${check.errorMessage}`);
+const reportDoctorResult = (presenter, outputMode) => (result) => {
+    presenter.reportResult(outputMode === "json"
+        ? result
+        : result.checks.map(formatCheck).join("\n"));
+};
+export const makeDoctorCommand = (dependencies, config, env) => new Command()
     .name("doctor")
     .description("Verify the repository setup according to the DevEx guidelines")
-    .action(async () => {
+    .action(async function () {
+    const { output } = this.optsWithGlobals();
+    const outputMode = resolveOutputMode(env, output);
+    const presenter = createCommandPresenter(outputMode);
     const result = await runDoctor(dependencies, config);
-    printDoctorResult(dependencies, result);
-    const exitCode = result.hasErrors ? 1 : 0;
-    process.exit(exitCode);
+    reportDoctorResult(presenter, outputMode)(result);
+    process.exitCode = result.hasErrors ? 1 : 0;
 });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,3 +1,4 @@
 import { Command } from "commander";
-import { Dependencies } from "../../../domain/dependencies.js";
-export declare const makeInfoCommand: (dependencies: Dependencies) => Command;
+import type { Dependencies } from "../../../domain/dependencies.js";
+import type { CliEnv } from "../env.js";
+export declare const makeInfoCommand: (dependencies: Dependencies, env: CliEnv) => Command;

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

@@ -1,9 +1,13 @@
 import { Command } from "commander";
-import { getInfo, printInfo } from "../../../domain/info.js";
-export const makeInfoCommand = (dependencies) => new Command()
+import { getInfo } from "../../../domain/info.js";
+import { createCommandPresenter, resolveOutputMode, } from "../presenters/index.js";
+export const makeInfoCommand = (dependencies, env) => new Command()
     .name("info")
     .description("Display information about the project")
-    .action(async () => {
+    .action(async function () {
+    const { output } = this.optsWithGlobals();
+    const presenter = createCommandPresenter(resolveOutputMode(env, output));
     const result = await getInfo(dependencies)();
-    printInfo(result);
+    presenter.reportResult(result);
 });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,8 +1,14 @@
 import { Command } from "commander";
 import { ResultAsync } from "neverthrow";
+import { z } from "zod";
+import type { CommandPresenter } from "../../../domain/command-presenter.js";
+import type { CliEnv } from "../env.js";
 import { GitHubAuthFactory } from "../../../domain/dependencies.js";
 import { Payload as MonorepoPayload } from "../../plop/generators/monorepo/index.js";
-export declare const checkInitPreconditions: () => ResultAsync<import("execa").Result<{
+type InitInitialAnswers = Partial<MonorepoPayload> & {
+    publishToGitHub?: boolean;
+};
+export declare const runInitPreconditions: (presenter: CommandPresenter) => ResultAsync<import("execa").Result<{
     environment: {
         NO_COLOR: string;
         TF_IN_AUTOMATION: string;
@@ -10,7 +16,7 @@ export declare const checkInitPreconditions: () => ResultAsync<import("execa").R
     };
     shell: true;
 }>, Error>;
-export declare const checkAddEnvironmentPreconditions: () => ResultAsync<import("execa").Result<{
+export declare const runAddEnvironmentPreconditions: (presenter: CommandPresenter) => ResultAsync<import("execa").Result<{
     environment: {
         NO_COLOR: string;
         TF_IN_AUTOMATION: string;
@@ -18,5 +24,32 @@ export declare const checkAddEnvironmentPreconditions: () => ResultAsync<import(
     };
     shell: true;
 }>, Error>;
-export declare const confirmGitHubRepoCreation: (payload: MonorepoPayload) => ResultAsync<boolean, Error>;
-export declare const makeInitCommand: (requireGitHubAuth: GitHubAuthFactory) => Command;
+export declare const initCommandOptionsSchema: z.ZodObject<{
+    description: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    owner: z.ZodOptional<z.ZodString>;
+    publish: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type InitCommandOptions = z.infer<typeof initCommandOptionsSchema>;
+export declare const parseInitCommandOptions: (input: unknown) => InitCommandOptions;
+export declare const getMonorepoInitialAnswers: ({ description, name, owner, publish, }: InitCommandOptions) => InitInitialAnswers;
+/**
+ * Translates a failure of the git remote setup step into an actionable error.
+ *
+ * When `git remote add origin` exits with code 3 the remote already exists,
+ * which is a recoverable situation: the message tells the user how to fix it.
+ * The original ExecaError is preserved as `cause` so `--verbose` still surfaces
+ * the exit code and git's own stderr.
+ */
+export declare const mapGitRemoteAddError: (cause: unknown) => Error;
+/**
+ * Resolves whether the scaffolded repository should be published to GitHub.
+ *
+ * When the caller already knows the answer (e.g. the user passed `--publish`
+ * on the command line), that value is used as-is and no prompt is shown. When
+ * the preference is left undefined (flag omitted), the user is asked
+ * interactively.
+ */
+export declare const confirmGitHubRepoCreation: (payload: MonorepoPayload, publishPreference?: boolean) => ResultAsync<boolean, Error>;
+export declare const makeInitCommand: (requireGitHubAuth: GitHubAuthFactory, env: CliEnv) => Command;
+export {};

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

@@ -1,24 +1,17 @@
 import { getLogger } from "@logtape/logtape";
 import chalk from "chalk";
-import { Command } from "commander";
+import { Command, Option } from "commander";
 import { $, ExecaError } from "execa";
 import inquirer from "inquirer";
-import { okAsync, ResultAsync } from "neverthrow";
+import { errAsync, okAsync, ResultAsync } from "neverthrow";
 import * as path from "node:path";
-import { oraPromise } from "ora";
 import { z } from "zod";
 import { Repository, } from "../../../domain/github.js";
 import { tf$ } from "../../execa/terraform.js";
 import { collectMonorepoPayload, getPlopInstance, runMonorepoActions, } from "../../plop/index.js";
-import { exitWithError } from "../index.js";
-import { createCommandPresenter } from "../presenters/index.js";
+import { asError, reportCommandError } from "../command-errors.js";
+import { createCommandPresenter, resolveOutputMode, } from "../presenters/index.js";
 const isGitHubRepoCreationSkipped = (input) => "gitHubRepoCreationSkipped" in input;
-const withSpinner = (text, successText, failText, task) => ResultAsync.fromPromise(oraPromise(task(), {
-    failText,
-    successText,
-    text,
-}), (cause) => new Error(failText, { cause }));
-const asError = (message) => (cause) => new Error(message, { cause });
 const trackStep = (presenter, name, task, mapError) => ResultAsync.fromPromise(presenter.trackStep(name, task), mapError);
 const displaySummary = (input) => {
     const docsUrl = "https://dx.pagopa.it/getting-started";
@@ -56,10 +49,8 @@ const displaySummary = (input) => {
     }
 };
 const checkTerraformCli = () => tf$ `terraform -version`;
-const checkTerraformCliIsInstalled = () => withSpinner("Checking Terraform installation...", "Terraform is installed!", "Please install terraform CLI before running this command. If you use tfenv, run: tfenv install latest && tfenv use latest", checkTerraformCli);
 const trackTerraformCliIsInstalled = (presenter) => trackStep(presenter, "Checking Terraform installation...", checkTerraformCli, asError("Please install terraform CLI before running this command. If you use tfenv, run: tfenv install latest && tfenv use latest"));
 const checkCorepack = () => tf$ `corepack -v`;
-const checkCorepackIsInstalled = () => withSpinner("Checking Corepack installation...", "Corepack is installed!", "Please install Corepack before running this command.", checkCorepack);
 const trackCorepackIsInstalled = (presenter) => trackStep(presenter, "Checking Corepack installation...", checkCorepack, asError("Please install Corepack before running this command."));
 const azureAccountSchema = z.object({
     user: z.object({
@@ -75,13 +66,45 @@ const ensureAzLogin = async () => {
     const { user } = azureAccountSchema.parse(parsed);
     return user.name;
 };
-const checkAzLogin = () => withSpinner("Check Azure login status...", (userName) => `You are logged in to Azure (${userName})`, "Please log in to Azure CLI using `az login` before running this command.", ensureAzLogin);
-const runInitPreconditions = (presenter) => trackTerraformCliIsInstalled(presenter).andThen(() => trackCorepackIsInstalled(presenter));
+const trackAzLogin = (presenter) => trackStep(presenter, "Checking Azure login status...", ensureAzLogin, asError("Please log in to Azure CLI using `az login` before running this command."));
 // TODO(CES-1810): Make these checks concurrent to speed up the preconditions check phase
-export const checkInitPreconditions = () => checkTerraformCliIsInstalled().andThen(() => checkCorepackIsInstalled());
-export const checkAddEnvironmentPreconditions = () => checkTerraformCliIsInstalled()
-    .andThen(() => checkAzLogin())
-    .andThen(() => checkCorepackIsInstalled());
+export const runInitPreconditions = (presenter) => trackTerraformCliIsInstalled(presenter).andThen(() => trackCorepackIsInstalled(presenter));
+// TODO(CES-1810): Make these checks concurrent to speed up the preconditions check phase
+export const runAddEnvironmentPreconditions = (presenter) => trackTerraformCliIsInstalled(presenter)
+    .andThen(() => trackAzLogin(presenter))
+    .andThen(() => trackCorepackIsInstalled(presenter));
+const DEFAULT_GITHUB_PUBLISH_CONFIRMATION = true;
+export const initCommandOptionsSchema = z.object({
+    description: z.string().optional(),
+    name: z.string().trim().min(1, "Repository name cannot be empty").optional(),
+    owner: z.string().trim().min(1, "GitHub owner cannot be empty").optional(),
+    publish: z.boolean().optional(),
+});
+export const parseInitCommandOptions = (input) => {
+    const result = initCommandOptionsSchema.safeParse(input);
+    if (!result.success) {
+        throw new Error(`Invalid init command options:\n${z.prettifyError(result.error)}`, {
+            cause: result.error,
+        });
+    }
+    return result.data;
+};
+export const getMonorepoInitialAnswers = ({ description, name, owner, publish, }) => {
+    const initialAnswers = {};
+    if (description) {
+        initialAnswers.repoDescription = description;
+    }
+    if (owner) {
+        initialAnswers.repoOwner = owner;
+    }
+    if (name) {
+        initialAnswers.repoName = name;
+    }
+    if (typeof publish === "boolean") {
+        initialAnswers.publishToGitHub = publish;
+    }
+    return initialAnswers;
+};
 const createRemoteRepositoryWithPresenter = (presenter) => ({ repoName, repoOwner, }) => {
     const logger = getLogger(["dx-cli", "init"]);
     const repo$ = tf$({ cwd: path.resolve("infra", "repository") });
@@ -99,14 +122,42 @@ const createRemoteRepositoryWithPresenter = (presenter) => ({ repoName, repoOwne
     };
     return trackStep(presenter, "Creating GitHub repository...", applyTerraform, asError("Failed to create GitHub repository.")).map(() => new Repository(repoName, repoOwner));
 };
+/**
+ * Exit code returned by `git remote add` when a remote with the requested name
+ * already exists. `git remote` documents this dedicated status code, so we can
+ * turn it into actionable guidance instead of a generic failure message.
+ *
+ * See https://git-scm.com/docs/git-remote#_exit_status
+ */
+const GIT_REMOTE_ALREADY_EXISTS_EXIT_CODE = 3;
+/**
+ * Translates a failure of the git remote setup step into an actionable error.
+ *
+ * When `git remote add origin` exits with code 3 the remote already exists,
+ * which is a recoverable situation: the message tells the user how to fix it.
+ * The original ExecaError is preserved as `cause` so `--verbose` still surfaces
+ * the exit code and git's own stderr.
+ */
+export const mapGitRemoteAddError = (cause) => {
+    if (cause instanceof ExecaError &&
+        cause.exitCode === GIT_REMOTE_ALREADY_EXISTS_EXIT_CODE) {
+        return new Error("A git remote named 'origin' already exists. Remove it with `git remote remove origin` and run the command again, or start from a clean directory.", { cause });
+    }
+    return new Error("Failed to set up the local git repository and its 'origin' remote.", { cause });
+};
 const initializeGitRepositoryWithPresenter = (presenter) => (repository) => {
     const branchName = "features/scaffold-workspace";
     const git$ = $({
         shell: true,
     });
-    const pushToOrigin = async () => {
+    // `git remote add` is tracked separately from the push so its documented
+    // exit codes (e.g. 3 = remote already exists) surface a specific, actionable
+    // message instead of being misreported as a push failure.
+    const configureRemote = async () => {
         await git$ `git init`;
         await git$ `git remote add origin ${repository.origin}`;
+    };
+    const pushToOrigin = async () => {
         await git$ `git fetch origin main`;
         await git$ `git checkout -b ${branchName}`;
         // Terraform creates `main` with an initial README commit.
@@ -117,7 +168,9 @@ const initializeGitRepositoryWithPresenter = (presenter) => (repository) => {
         await git$ `git commit --no-gpg-sign -m "Scaffold workspace"`;
         await git$ `git push -u origin ${branchName}`;
     };
-    return trackStep(presenter, "Pushing code to GitHub...", pushToOrigin, asError("Failed to push code to GitHub.")).map(() => ({ branchName, repository }));
+    return trackStep(presenter, "Configuring the git remote...", configureRemote, mapGitRemoteAddError)
+        .andThen(() => trackStep(presenter, "Pushing code to GitHub...", pushToOrigin, asError("Failed to push code to GitHub.")))
+        .map(() => ({ branchName, repository }));
 };
 const createPullRequestWithPresenter = ({ gitHubService, presenter }) => ({ branchName, repository, }) => trackStep(presenter, "Creating Pull Request...", () => gitHubService.createPullRequest({
     base: "main",
@@ -142,29 +195,54 @@ const handleGeneratorError = (err) => {
     }
     return new Error("Failed to run the generator", { cause: err });
 };
-export const confirmGitHubRepoCreation = (payload) => ResultAsync.fromPromise(inquirer
-    .prompt({
-    default: true,
-    message: `The project is created on ${chalk.green(payload.repoName)}. Would you like to publish it to GitHub at ${chalk.green(`${payload.repoOwner}/${payload.repoName}`)} now?`,
-    name: "confirm",
-    type: "confirm",
-})
-    .then(({ confirm }) => confirm), (cause) => new Error("Failed to read GitHub publish confirmation", { cause }));
-const runInitAction = ({ gitHubService, presenter, }) => trackStep(presenter, "Initializing workspace generator...", getPlopInstance, asError("Failed to initialize plop"))
-    .andThen((plop) => 
-// The prompt phase must run outside trackStep: in text mode trackStep
-// renders a spinner that occupies the TTY and hides the prompts.
-ResultAsync.fromPromise(collectMonorepoPayload(plop, gitHubService), handleGeneratorError))
-    .andThen(({ generator, payload }) => trackStep(presenter, "Scaffolding workspace...", () => runMonorepoActions(generator, payload), handleGeneratorError))
-    .andTee((payload) => {
-    process.chdir(payload.repoName);
-})
-    .andThen((payload) => confirmGitHubRepoCreation(payload).andThen((confirmed) => confirmed
-    ? handleNewGitHubRepositoryWithPresenter({
-        gitHubService,
-        presenter,
-    })(payload)
-    : okAsync({ gitHubRepoCreationSkipped: true, payload })));
+/**
+ * Resolves whether the scaffolded repository should be published to GitHub.
+ *
+ * When the caller already knows the answer (e.g. the user passed `--publish`
+ * on the command line), that value is used as-is and no prompt is shown. When
+ * the preference is left undefined (flag omitted), the user is asked
+ * interactively.
+ */
+export const confirmGitHubRepoCreation = (payload, publishPreference) => 
+// A preference provided up-front (via `--publish`) skips the interactive prompt.
+publishPreference !== undefined
+    ? okAsync(publishPreference)
+    : ResultAsync.fromPromise(inquirer.prompt({
+        default: DEFAULT_GITHUB_PUBLISH_CONFIRMATION,
+        message: `The project is created on ${chalk.green(payload.repoName)}. Would you like to publish it to GitHub at ${chalk.green(`${payload.repoOwner}/${payload.repoName}`)} now?`,
+        name: "confirm",
+        type: "confirm",
+    }), (cause) => new Error("Failed to read GitHub publish confirmation", { cause })).andThen((answer) => {
+        const parsedAnswer = z
+            .object({
+            confirm: z.boolean(),
+        })
+            .safeParse(answer);
+        if (!parsedAnswer.success) {
+            return errAsync(new Error("Invalid GitHub publish confirmation", {
+                cause: parsedAnswer.error,
+            }));
+        }
+        return okAsync(parsedAnswer.data.confirm);
+    });
+const runInitAction = ({ gitHubService, initialAnswers = {}, presenter, }) => {
+    const { publishToGitHub, ...monorepoInitialAnswers } = initialAnswers;
+    return trackStep(presenter, "Initializing workspace generator...", getPlopInstance, asError("Failed to initialize plop"))
+        .andThen((plop) => 
+    // The prompt phase must run outside trackStep: in text mode trackStep
+    // renders a spinner that occupies the TTY and hides the prompts.
+    ResultAsync.fromPromise(collectMonorepoPayload(plop, gitHubService, monorepoInitialAnswers), handleGeneratorError))
+        .andThen(({ generator, payload }) => trackStep(presenter, "Scaffolding workspace...", () => runMonorepoActions(generator, payload), handleGeneratorError))
+        .andTee((payload) => {
+        process.chdir(payload.repoName);
+    })
+        .andThen((payload) => confirmGitHubRepoCreation(payload, publishToGitHub).andThen((confirmed) => confirmed
+        ? handleNewGitHubRepositoryWithPresenter({
+            gitHubService,
+            presenter,
+        })(payload)
+        : okAsync({ gitHubRepoCreationSkipped: true, payload })));
+};
 const reportSummary = (presenter, outputMode) => (result) => {
     if (outputMode === "json") {
         presenter.reportResult(result);
@@ -173,23 +251,27 @@ const reportSummary = (presenter, outputMode) => (result) => {
         displaySummary(result);
     }
 };
-const reportCommandError = (command, presenter, outputMode) => (error) => {
-    if (outputMode === "json") {
-        presenter.reportError(error);
-        process.exitCode = 1;
-    }
-    else {
-        exitWithError(command)(error);
-    }
-};
-export const makeInitCommand = (requireGitHubAuth) => new Command()
+export const makeInitCommand = (requireGitHubAuth, env) => new Command()
     .name("init")
     .description("Initialize a new DX workspace")
-    .action(async function () {
+    .addOption(new Option("--name <name>", "Repository name"))
+    .addOption(new Option("--owner <owner>", "GitHub organization or user that will own the repository"))
+    .addOption(new Option("--description <description>", "Repository description"))
+    .addOption(new Option("--publish", "Publish the scaffolded repository to GitHub without prompting").default(undefined))
+    .action(async function (options) {
     const { output } = this.optsWithGlobals();
-    const presenter = createCommandPresenter(output);
-    await runInitPreconditions(presenter)
+    const outputMode = resolveOutputMode(env, output);
+    const presenter = createCommandPresenter(outputMode);
+    await ResultAsync.fromPromise(Promise.resolve().then(() => parseInitCommandOptions(options)), (cause) => cause instanceof Error
+        ? cause
+        : new Error("Failed to parse init command options", { cause }))
+        .andThen((initOptions) => runInitPreconditions(presenter)
         .andThen(() => requireGitHubAuth())
-        .andThen((auth) => runInitAction({ gitHubService: auth.gitHubService, presenter }))
-        .match(reportSummary(presenter, output), reportCommandError(this, presenter, output));
+        .andThen((auth) => runInitAction({
+        gitHubService: auth.gitHubService,
+        initialAnswers: getMonorepoInitialAnswers(initOptions),
+        presenter,
+    })))
+        .match(reportSummary(presenter, outputMode), reportCommandError(this, presenter, outputMode));
 });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"init.js","sourceRoot":"","sources":["../../../../src/adapters/commander/commands/init.ts"],"names":[],"mappings":"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","sourcesContent":["import { getLogger } from \"@logtape/logtape\";\nimport chalk from \"chalk\";\nimport { Command, Option } from \"commander\";\nimport { $, ExecaError } from \"execa\";\nimport inquirer from \"inquirer\";\nimport { errAsync, okAsync, ResultAsync } from \"neverthrow\";\nimport * as path from \"node:path\";\nimport { z } from \"zod\";\n\nimport type { CommandPresenter } from \"../../../domain/command-presenter.js\";\nimport type { CliEnv } from \"../env.js\";\nimport type { GlobalOptions } from \"../global-options.js\";\n\nimport { GitHubAuthFactory } from \"../../../domain/dependencies.js\";\nimport {\n  GitHubService,\n  PullRequest,\n  Repository,\n} from \"../../../domain/github.js\";\nimport { tf$ } from \"../../execa/terraform.js\";\nimport { Payload as MonorepoPayload } from \"../../plop/generators/monorepo/index.js\";\nimport {\n  collectMonorepoPayload,\n  getPlopInstance,\n  runMonorepoActions,\n} from \"../../plop/index.js\";\nimport { asError, reportCommandError } from \"../command-errors.js\";\nimport {\n  createCommandPresenter,\n  resolveOutputMode,\n} from \"../presenters/index.js\";\n\ntype GitHubRepoCreationSkippedResult = {\n  gitHubRepoCreationSkipped: true;\n  payload: MonorepoPayload;\n};\n\ntype InitResult = {\n  pr?: PullRequest;\n  repository?: Repository;\n};\n\ntype SummaryInput = GitHubRepoCreationSkippedResult | InitResult;\n\nconst isGitHubRepoCreationSkipped = (\n  input: SummaryInput,\n): input is GitHubRepoCreationSkippedResult =>\n  \"gitHubRepoCreationSkipped\" in input;\n\ntype InitActionContext = {\n  gitHubService: GitHubService;\n  initialAnswers?: InitInitialAnswers;\n  presenter: CommandPresenter;\n};\n\ntype InitInitialAnswers = Partial<MonorepoPayload> & {\n  publishToGitHub?: boolean;\n};\n\ntype LocalWorkspace = {\n  branchName: string;\n  repository: Repository;\n};\n\ntype RepositoryPullRequest = {\n  pr?: PullRequest;\n  repository: Repository;\n};\n\nconst trackStep = <T, E>(\n  presenter: CommandPresenter,\n  name: string,\n  task: () => Promise<T>,\n  mapError: (cause: unknown) => E,\n): ResultAsync<T, E> =>\n  ResultAsync.fromPromise(presenter.trackStep(name, task), mapError);\n\nconst displaySummary = (input: SummaryInput) => {\n  const docsUrl = \"https://dx.pagopa.it/getting-started\";\n\n  if (isGitHubRepoCreationSkipped(input)) {\n    const { payload } = input;\n    console.log(chalk.yellow.bold(\"\\nGitHub repository creation skipped.\"));\n    console.log(\n      `The workspace files have been scaffolded in ${chalk.cyan(payload.repoName + \"/\")}.`,\n    );\n    console.log(chalk.bold(\"\\nTo finish the setup manually:\"));\n    let step = 1;\n    console.log(\n      `${step++}. Create the GitHub repository by applying the Terraform config scaffolded at ${chalk.cyan(`${payload.repoName}/infra/repository`)}:`,\n    );\n    console.log(\n      `       ${chalk.cyan(`cd ${payload.repoName}/infra/repository && terraform init && terraform apply`)}`,\n    );\n    console.log(\n      `${step++}. Push the scaffolded code to the newly created repository:`,\n    );\n    console.log(\n      `       ${chalk.cyan(`cd ${payload.repoName} && git init && git remote add origin <url> && git push`)}`,\n    );\n    console.log(\n      `${step}. Visit ${chalk.underline(docsUrl)} to deploy your first project\\n`,\n    );\n    return;\n  }\n\n  const { pr, repository } = input;\n  console.log(chalk.green.bold(\"\\nWorkspace created successfully!\"));\n\n  if (repository) {\n    console.log(`- Name: ${chalk.cyan(repository.name)}`);\n    console.log(`- GitHub Repository: ${chalk.cyan(repository.url)}\\n`);\n  } else {\n    console.log(\n      chalk.yellow(\n        `\\n⚠️ GitHub repository may not have been created automatically.`,\n      ),\n    );\n  }\n\n  if (pr) {\n    let step = 1;\n    console.log(chalk.green.bold(\"\\nNext Steps:\"));\n    console.log(\n      `${step++}. Review the Pull Request in the GitHub repository: ${chalk.underline(pr.url)}`,\n    );\n    console.log(\n      `${step}. Visit ${chalk.underline(docsUrl)} to deploy your first project\\n`,\n    );\n  } else {\n    console.log(\n      chalk.yellow(`\\n⚠️ There was an error during Pull Request creation.`),\n    );\n    console.log(\n      `Please, manually create a Pull Request in the GitHub repository to review the scaffolded code.\\n`,\n    );\n  }\n};\n\nconst checkTerraformCli = () => tf$`terraform -version`;\n\nconst trackTerraformCliIsInstalled = (presenter: CommandPresenter) =>\n  trackStep(\n    presenter,\n    \"Checking Terraform installation...\",\n    checkTerraformCli,\n    asError(\n      \"Please install terraform CLI before running this command. If you use tfenv, run: tfenv install latest && tfenv use latest\",\n    ),\n  );\n\nconst checkCorepack = () => tf$`corepack -v`;\n\nconst trackCorepackIsInstalled = (presenter: CommandPresenter) =>\n  trackStep(\n    presenter,\n    \"Checking Corepack installation...\",\n    checkCorepack,\n    asError(\"Please install Corepack before running this command.\"),\n  );\n\nconst azureAccountSchema = z.object({\n  user: z.object({\n    name: z.string().min(1),\n  }),\n});\n\nconst ensureAzLogin = async (): Promise<string> => {\n  const { stdout } = await tf$`az account show`;\n  // `az account show` reads the cached CLI context, but `az group list`\n  // fails when the current session token has expired.\n  await tf$`az group list`;\n  const parsed = JSON.parse(stdout);\n  const { user } = azureAccountSchema.parse(parsed);\n  return user.name;\n};\n\nconst trackAzLogin = (presenter: CommandPresenter) =>\n  trackStep(\n    presenter,\n    \"Checking Azure login status...\",\n    ensureAzLogin,\n    asError(\n      \"Please log in to Azure CLI using `az login` before running this command.\",\n    ),\n  );\n\n// TODO(CES-1810): Make these checks concurrent to speed up the preconditions check phase\nexport const runInitPreconditions = (presenter: CommandPresenter) =>\n  trackTerraformCliIsInstalled(presenter).andThen(() =>\n    trackCorepackIsInstalled(presenter),\n  );\n\n// TODO(CES-1810): Make these checks concurrent to speed up the preconditions check phase\nexport const runAddEnvironmentPreconditions = (presenter: CommandPresenter) =>\n  trackTerraformCliIsInstalled(presenter)\n    .andThen(() => trackAzLogin(presenter))\n    .andThen(() => trackCorepackIsInstalled(presenter));\n\nconst DEFAULT_GITHUB_PUBLISH_CONFIRMATION = true;\n\nexport const initCommandOptionsSchema = z.object({\n  description: z.string().optional(),\n  name: z.string().trim().min(1, \"Repository name cannot be empty\").optional(),\n  owner: z.string().trim().min(1, \"GitHub owner cannot be empty\").optional(),\n  publish: z.boolean().optional(),\n});\n\nexport type InitCommandOptions = z.infer<typeof initCommandOptionsSchema>;\n\nexport const parseInitCommandOptions = (input: unknown): InitCommandOptions => {\n  const result = initCommandOptionsSchema.safeParse(input);\n  if (!result.success) {\n    throw new Error(\n      `Invalid init command options:\\n${z.prettifyError(result.error)}`,\n      {\n        cause: result.error,\n      },\n    );\n  }\n\n  return result.data;\n};\n\nexport const getMonorepoInitialAnswers = ({\n  description,\n  name,\n  owner,\n  publish,\n}: InitCommandOptions): InitInitialAnswers => {\n  const initialAnswers: InitInitialAnswers = {};\n\n  if (description) {\n    initialAnswers.repoDescription = description;\n  }\n\n  if (owner) {\n    initialAnswers.repoOwner = owner;\n  }\n\n  if (name) {\n    initialAnswers.repoName = name;\n  }\n\n  if (typeof publish === \"boolean\") {\n    initialAnswers.publishToGitHub = publish;\n  }\n\n  return initialAnswers;\n};\n\nconst createRemoteRepositoryWithPresenter =\n  (presenter: CommandPresenter) =>\n  ({\n    repoName,\n    repoOwner,\n  }: MonorepoPayload): ResultAsync<Repository, Error> => {\n    const logger = getLogger([\"dx-cli\", \"init\"]);\n    const repo$ = tf$({ cwd: path.resolve(\"infra\", \"repository\") });\n    const applyTerraform = async () => {\n      try {\n        await repo$`terraform init`;\n        await repo$`terraform apply -auto-approve`;\n      } catch (error) {\n        if (error instanceof ExecaError) {\n          logger.error(error.shortMessage);\n        }\n        throw error;\n      }\n    };\n    return trackStep(\n      presenter,\n      \"Creating GitHub repository...\",\n      applyTerraform,\n      asError(\"Failed to create GitHub repository.\"),\n    ).map(() => new Repository(repoName, repoOwner));\n  };\n/**\n * Exit code returned by `git remote add` when a remote with the requested name\n * already exists. `git remote` documents this dedicated status code, so we can\n * turn it into actionable guidance instead of a generic failure message.\n *\n * See https://git-scm.com/docs/git-remote#_exit_status\n */\nconst GIT_REMOTE_ALREADY_EXISTS_EXIT_CODE = 3;\n\n/**\n * Translates a failure of the git remote setup step into an actionable error.\n *\n * When `git remote add origin` exits with code 3 the remote already exists,\n * which is a recoverable situation: the message tells the user how to fix it.\n * The original ExecaError is preserved as `cause` so `--verbose` still surfaces\n * the exit code and git's own stderr.\n */\nexport const mapGitRemoteAddError = (cause: unknown): Error => {\n  if (\n    cause instanceof ExecaError &&\n    cause.exitCode === GIT_REMOTE_ALREADY_EXISTS_EXIT_CODE\n  ) {\n    return new Error(\n      \"A git remote named 'origin' already exists. Remove it with `git remote remove origin` and run the command again, or start from a clean directory.\",\n      { cause },\n    );\n  }\n  return new Error(\n    \"Failed to set up the local git repository and its 'origin' remote.\",\n    { cause },\n  );\n};\n\nconst initializeGitRepositoryWithPresenter =\n  (presenter: CommandPresenter) => (repository: Repository) => {\n    const branchName = \"features/scaffold-workspace\";\n    const git$ = $({\n      shell: true,\n    });\n    // `git remote add` is tracked separately from the push so its documented\n    // exit codes (e.g. 3 = remote already exists) surface a specific, actionable\n    // message instead of being misreported as a push failure.\n    const configureRemote = async () => {\n      await git$`git init`;\n      await git$`git remote add origin ${repository.origin}`;\n    };\n    const pushToOrigin = async () => {\n      await git$`git fetch origin main`;\n      await git$`git checkout -b ${branchName}`;\n      // Terraform creates `main` with an initial README commit.\n      // Reset to `origin/main` so this branch is based on the remote default branch,\n      // while keeping the scaffolded local files in the working tree for a clean PR diff.\n      await git$`git reset origin/main`;\n      await git$`git add .`;\n      await git$`git commit --no-gpg-sign -m \"Scaffold workspace\"`;\n      await git$`git push -u origin ${branchName}`;\n    };\n    return trackStep(\n      presenter,\n      \"Configuring the git remote...\",\n      configureRemote,\n      mapGitRemoteAddError,\n    )\n      .andThen(() =>\n        trackStep(\n          presenter,\n          \"Pushing code to GitHub...\",\n          pushToOrigin,\n          asError(\"Failed to push code to GitHub.\"),\n        ),\n      )\n      .map(() => ({ branchName, repository }));\n  };\n\nconst createPullRequestWithPresenter =\n  ({ gitHubService, presenter }: InitActionContext) =>\n  ({\n    branchName,\n    repository,\n  }: LocalWorkspace): ResultAsync<PullRequest | undefined, Error> =>\n    trackStep(\n      presenter,\n      \"Creating Pull Request...\",\n      () =>\n        gitHubService.createPullRequest({\n          base: \"main\",\n          body: \"This PR contains the scaffolded monorepo structure.\",\n          head: branchName,\n          owner: repository.owner,\n          repo: repository.name,\n          title: \"Scaffold repository\",\n        }),\n      asError(\"Failed to create Pull Request.\"),\n    )\n      // If PR creation fails, don't block the workflow\n      .orElse(() => okAsync(undefined));\n\nconst handleNewGitHubRepositoryWithPresenter =\n  (context: InitActionContext) =>\n  (payload: MonorepoPayload): ResultAsync<RepositoryPullRequest, Error> =>\n    createRemoteRepositoryWithPresenter(context.presenter)(payload)\n      .andThen(initializeGitRepositoryWithPresenter(context.presenter))\n      .andThen((localWorkspace) =>\n        createPullRequestWithPresenter(context)(localWorkspace).map((pr) => ({\n          pr,\n          repository: localWorkspace.repository,\n        })),\n      );\n\nconst handleGeneratorError = (err: unknown) => {\n  const logger = getLogger([\"dx-cli\", \"init\"]);\n  if (err instanceof Error) {\n    logger.error(err.message);\n  }\n  return new Error(\"Failed to run the generator\", { cause: err });\n};\n\n/**\n * Resolves whether the scaffolded repository should be published to GitHub.\n *\n * When the caller already knows the answer (e.g. the user passed `--publish`\n * on the command line), that value is used as-is and no prompt is shown. When\n * the preference is left undefined (flag omitted), the user is asked\n * interactively.\n */\nexport const confirmGitHubRepoCreation = (\n  payload: MonorepoPayload,\n  publishPreference?: boolean,\n): ResultAsync<boolean, Error> =>\n  // A preference provided up-front (via `--publish`) skips the interactive prompt.\n  publishPreference !== undefined\n    ? okAsync(publishPreference)\n    : ResultAsync.fromPromise(\n        inquirer.prompt({\n          default: DEFAULT_GITHUB_PUBLISH_CONFIRMATION,\n          message: `The project is created on ${chalk.green(payload.repoName)}. Would you like to publish it to GitHub at ${chalk.green(`${payload.repoOwner}/${payload.repoName}`)} now?`,\n          name: \"confirm\",\n          type: \"confirm\",\n        }),\n        (cause) =>\n          new Error(\"Failed to read GitHub publish confirmation\", { cause }),\n      ).andThen((answer) => {\n        const parsedAnswer = z\n          .object({\n            confirm: z.boolean(),\n          })\n          .safeParse(answer);\n        if (!parsedAnswer.success) {\n          return errAsync(\n            new Error(\"Invalid GitHub publish confirmation\", {\n              cause: parsedAnswer.error,\n            }),\n          );\n        }\n\n        return okAsync(parsedAnswer.data.confirm);\n      });\n\nconst runInitAction = ({\n  gitHubService,\n  initialAnswers = {},\n  presenter,\n}: InitActionContext): ResultAsync<SummaryInput, Error> => {\n  const { publishToGitHub, ...monorepoInitialAnswers } = initialAnswers;\n\n  return trackStep(\n    presenter,\n    \"Initializing workspace generator...\",\n    getPlopInstance,\n    asError(\"Failed to initialize plop\"),\n  )\n    .andThen((plop) =>\n      // The prompt phase must run outside trackStep: in text mode trackStep\n      // renders a spinner that occupies the TTY and hides the prompts.\n      ResultAsync.fromPromise(\n        collectMonorepoPayload(plop, gitHubService, monorepoInitialAnswers),\n        handleGeneratorError,\n      ),\n    )\n    .andThen(({ generator, payload }) =>\n      trackStep(\n        presenter,\n        \"Scaffolding workspace...\",\n        () => runMonorepoActions(generator, payload),\n        handleGeneratorError,\n      ),\n    )\n    .andTee((payload) => {\n      process.chdir(payload.repoName);\n    })\n    .andThen((payload) =>\n      confirmGitHubRepoCreation(payload, publishToGitHub).andThen<\n        SummaryInput,\n        Error\n      >((confirmed) =>\n        confirmed\n          ? handleNewGitHubRepositoryWithPresenter({\n              gitHubService,\n              presenter,\n            })(payload)\n          : okAsync({ gitHubRepoCreationSkipped: true, payload }),\n      ),\n    );\n};\n\nconst reportSummary =\n  (presenter: CommandPresenter, outputMode: \"json\" | \"text\") =>\n  (result: SummaryInput) => {\n    if (outputMode === \"json\") {\n      presenter.reportResult(result);\n    } else {\n      displaySummary(result);\n    }\n  };\n\nexport const makeInitCommand = (\n  requireGitHubAuth: GitHubAuthFactory,\n  env: CliEnv,\n): Command =>\n  new Command()\n    .name(\"init\")\n    .description(\"Initialize a new DX workspace\")\n    .addOption(new Option(\"--name <name>\", \"Repository name\"))\n    .addOption(\n      new Option(\n        \"--owner <owner>\",\n        \"GitHub organization or user that will own the repository\",\n      ),\n    )\n    .addOption(\n      new Option(\"--description <description>\", \"Repository description\"),\n    )\n    .addOption(\n      new Option(\n        \"--publish\",\n        \"Publish the scaffolded repository to GitHub without prompting\",\n      ).default(undefined),\n    )\n    .action(async function (options: unknown) {\n      const { output } = this.optsWithGlobals<GlobalOptions>();\n      const outputMode = resolveOutputMode(env, output);\n      const presenter = createCommandPresenter(outputMode);\n\n      await ResultAsync.fromPromise(\n        Promise.resolve().then(() => parseInitCommandOptions(options)),\n        (cause) =>\n          cause instanceof Error\n            ? cause\n            : new Error(\"Failed to parse init command options\", { cause }),\n      )\n        .andThen((initOptions) =>\n          runInitPreconditions(presenter)\n            .andThen(() => requireGitHubAuth())\n            .andThen((auth) =>\n              runInitAction({\n                gitHubService: auth.gitHubService,\n                initialAnswers: getMonorepoInitialAnswers(initOptions),\n                presenter,\n              }),\n            ),\n        )\n        .match(\n          reportSummary(presenter, outputMode),\n          reportCommandError(this, presenter, outputMode),\n        );\n    });\n"]}

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

@@ -2,7 +2,7 @@ import { azure, loadConfig } from "@pagopa/dx-savemoney";
 import { Command, InvalidArgumentError } from "commander";
 import { oraPromise } from "ora";
 import { z } from "zod";
-import { exitWithError } from "../index.js";
+import { exitWithError } from "../command-errors.js";
 export const makeSavemoneyCommand = () => new Command("savemoney")
     .description("Analyze Azure subscriptions and report unused or inefficient resources")
     .option("-c, --config <path>", "Path to YAML configuration file")
@@ -76,3 +76,4 @@ export function parseTagsOption(tagsOption) {
     }
     return result;
 }
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"savemoney.js","sourceRoot":"","sources":["../../../../src/adapters/commander/commands/savemoney.ts"],"names":[],"mappings":"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","sourcesContent":["import type { AzureConfig, AzureSource } from \"@pagopa/dx-savemoney\";\n\nimport { azure, loadConfig } from \"@pagopa/dx-savemoney\";\nimport { Command, InvalidArgumentError } from \"commander\";\nimport { oraPromise } from \"ora\";\nimport { z } from \"zod\";\n\nimport { exitWithError } from \"../command-errors.js\";\nimport { GlobalOptions } from \"../global-options.js\";\n\nexport const makeSavemoneyCommand = () =>\n  new Command(\"savemoney\")\n    .description(\n      \"Analyze Azure subscriptions and report unused or inefficient resources\",\n    )\n    .option(\"-c, --config <path>\", \"Path to YAML configuration file\")\n    .option(\n      \"-f, --format <format>\",\n      \"Report format: json, table, detailed-json, or lint (default: table)\",\n      \"table\",\n    )\n    .option(\n      \"-l, --location <string>\",\n      \"Preferred Azure location for resources (overrides config file)\",\n      \"italynorth\",\n    )\n    .option(\n      \"-d, --days <number>\",\n      \"Number of days for metrics analysis (overrides config file)\",\n      \"30\",\n    )\n    .option(\n      \"-t, --tags <tags...>\",\n      \"Filter findings by resource tags (key=value key2=value2). Advisor subscription-level findings remain global.\",\n    )\n    .option(\n      \"-s, --source <source>\",\n      \"Restrict findings to a single source: 'advisor', 'custom', or 'all' (default: all)\",\n      parseSourceOption,\n      \"all\",\n    )\n    .action(async function (options) {\n      const { verbose } = this.optsWithGlobals<GlobalOptions>();\n      try {\n        // Load configuration from YAML (includes subscriptionIds, location, timespanDays, thresholds)\n        const config: AzureConfig = await loadConfig(options.config);\n\n        // Parse tag filter\n        const filterTags = parseTagsOption(options.tags);\n\n        const finalConfig: AzureConfig = {\n          ...config,\n          filterTags,\n          preferredLocation: options.location || config.preferredLocation,\n          sources:\n            options.source === \"all\"\n              ? (config.sources ?? [\"advisor\", \"custom\"])\n              : [options.source as AzureSource],\n          timespanDays:\n            Number.parseInt(options.days, 10) || config.timespanDays,\n          verbose: verbose ?? false,\n        };\n\n        // Run analysis showing a progress spinner on stderr so the CLI doesn't\n        // look frozen during the (potentially several-minute) Azure round-trips.\n        const reports = await oraPromise(\n          azure.analyzeAzureResources(finalConfig),\n          {\n            failText: \"Analysis failed\",\n            stream: process.stderr,\n            successText: \"Analysis complete\",\n            text: \"Analyzing Azure resources\",\n          },\n        );\n        await azure.generateReport(reports, options.format);\n      } catch (error) {\n        exitWithError(this)(\n          error instanceof Error\n            ? new Error(`Analysis failed: ${error.message}`, { cause: error })\n            : new Error(`Analysis failed: ${String(error)}`),\n        );\n      }\n    });\n\nconst SourceSchema = z.enum([\"advisor\", \"all\", \"custom\"]);\n\n/**\n * Parses the `--source` option via a zod enum, accepting `all`, `advisor`,\n * or `custom` and rejecting any other value with a Commander-friendly error.\n */\nexport function parseSourceOption(value: string): string {\n  const result = SourceSchema.safeParse(value);\n  if (!result.success) {\n    throw new InvalidArgumentError(\n      `Allowed values are: ${SourceSchema.options.join(\", \")}`,\n    );\n  }\n  return result.data;\n}\n\n/**\n * Parses an array of \"key=value\" strings (from commander variadic option) into a Map<string, string>.\n * Returns an empty Map when the option is not provided or empty.\n * Supports values that contain \"=\" (only the first \"=\" is treated as separator).\n */\nexport function parseTagsOption(\n  tagsOption: string[] | undefined,\n): Map<string, string> {\n  const result = new Map<string, string>();\n  if (!tagsOption || tagsOption.length === 0) {\n    return result;\n  }\n  for (const pair of tagsOption) {\n    const [rawKey, ...rest] = pair.split(\"=\");\n    const key = rawKey?.trim();\n    const value = rest.join(\"=\").trim();\n    if (key && rest.length > 0) {\n      result.set(key, value);\n    }\n  }\n  return result;\n}\n"]}

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

@@ -11,3 +11,4 @@ export const makeSpecCommand = (getSpec) => new Command("spec")
     .action(() => {
     process.stdout.write(JSON.stringify(getSpec(), null, 2) + "\n");
 });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3BlYy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9hZGFwdGVycy9jb21tYW5kZXIvY29tbWFuZHMvc3BlYy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSCxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sV0FBVyxDQUFDO0FBSXBDLE1BQU0sQ0FBQyxNQUFNLGVBQWUsR0FBRyxDQUFDLE9BQXNCLEVBQVcsRUFBRSxDQUNqRSxJQUFJLE9BQU8sQ0FBQyxNQUFNLENBQUM7S0FDaEIsV0FBVyxDQUNWLHVLQUF1SyxDQUN4SztLQUNBLE1BQU0sQ0FBQyxHQUFHLEVBQUU7SUFDWCxPQUFPLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLE9BQU8sRUFBRSxFQUFFLElBQUksRUFBRSxDQUFDLENBQUMsR0FBRyxJQUFJLENBQUMsQ0FBQztBQUNsRSxDQUFDLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogU3BlYyBDb21tYW5kXG4gKlxuICogSW1wbGVtZW50cyB0aGUgYGR4IHNwZWNgIHN1YmNvbW1hbmQuIENhbGxzIHRoZSBpbmplY3RlZCBgZ2V0U3BlY2AgZmFjdG9yeVxuICogYW5kIHdyaXRlcyB0aGUgcmVzdWx0IGFzIHByZXR0eS1wcmludGVkIEpTT04gdG8gc3Rkb3V0LiAgVGhlIGNvbW1hbmQgaGFzIG5vXG4gKiBkZXBlbmRlbmNpZXMgYW5kIHJlcXVpcmVzIG5vIGF1dGhlbnRpY2F0aW9uLlxuICovXG5cbmltcG9ydCB7IENvbW1hbmQgfSBmcm9tIFwiY29tbWFuZGVyXCI7XG5cbmltcG9ydCB0eXBlIHsgQ2xpU3BlYyB9IGZyb20gXCIuLi8uLi8uLi9kb21haW4vc3BlYy5qc1wiO1xuXG5leHBvcnQgY29uc3QgbWFrZVNwZWNDb21tYW5kID0gKGdldFNwZWM6ICgpID0+IENsaVNwZWMpOiBDb21tYW5kID0+XG4gIG5ldyBDb21tYW5kKFwic3BlY1wiKVxuICAgIC5kZXNjcmlwdGlvbihcbiAgICAgIFwiUHJpbnQgdGhlIGZ1bGwgQ0xJIHNwZWMgYXMgSlNPTiAoY29tbWFuZHMsIHN1YmNvbW1hbmRzLCBmbGFncywgYXJndW1lbnRzKS4gVXNlZnVsIGZvciBhZ2VudHMgdGhhdCBuZWVkIHRvIHVuZGVyc3RhbmQgdGhlIENMSSB3aXRob3V0IHJ1bm5pbmcgLS1oZWxwIG9uIGV2ZXJ5IGNvbW1hbmQuXCIsXG4gICAgKVxuICAgIC5hY3Rpb24oKCkgPT4ge1xuICAgICAgcHJvY2Vzcy5zdGRvdXQud3JpdGUoSlNPTi5zdHJpbmdpZnkoZ2V0U3BlYygpLCBudWxsLCAyKSArIFwiXFxuXCIpO1xuICAgIH0pO1xuIl19

package/dist/adapters/commander/env.js

@@ -13,3 +13,4 @@ export const cliEnvSchema = z
     CI: z.stringbool().default(false),
 })
     .loose();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW52LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2FkYXB0ZXJzL2NvbW1hbmRlci9lbnYudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7R0FPRztBQUNILE9BQU8sRUFBRSxDQUFDLEVBQUUsTUFBTSxLQUFLLENBQUM7QUFFeEIsTUFBTSxDQUFDLE1BQU0sWUFBWSxHQUFHLENBQUM7S0FDMUIsTUFBTSxDQUFDO0lBQ04sd0NBQXdDO0lBQ3hDLEVBQUUsRUFBRSxDQUFDLENBQUMsVUFBVSxFQUFFLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQztDQUNsQyxDQUFDO0tBQ0QsS0FBSyxFQUFFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFpvZCBzY2hlbWEgZm9yIHRoZSBDTEkgZW52aXJvbm1lbnQgdmFyaWFibGVzLlxuICpcbiAqIEludGVuZGVkIHRvIGNlbnRyYWxpemUgZW52IHBhcnNpbmcgYXQgdGhlIGVudHJ5cG9pbnQgKGBzcmMvaW5kZXgudHNgKSxcbiAqIHdoaWNoIHdpbGwgcGFyc2UgdGhlIHJhdyBlbnZpcm9ubWVudCBvbmNlIGFuZCBwYXNzIHRoZSB2YWxpZGF0ZWQgcmVzdWx0IGFzXG4gKiBgQ2xpRW52YCB0byBldmVyeSBjb21tYW5kLiBUaGlzIGtlZXBzIGVudi12YXIgcmVhZHMgb3V0IG9mIHVzZS1jYXNlcyBhbmRcbiAqIGFkYXB0ZXJzIGFuZCBtYWtlcyB0aGVtIGZ1bGx5IHRlc3RhYmxlLlxuICovXG5pbXBvcnQgeyB6IH0gZnJvbSBcInpvZFwiO1xuXG5leHBvcnQgY29uc3QgY2xpRW52U2NoZW1hID0gelxuICAub2JqZWN0KHtcbiAgICAvLyBVc2UgYSB0cnV0aHkgdmFsdWUgdG8gZW5hYmxlIENJIG1vZGUuXG4gICAgQ0k6IHouc3RyaW5nYm9vbCgpLmRlZmF1bHQoZmFsc2UpLFxuICB9KVxuICAubG9vc2UoKTtcblxuZXhwb3J0IHR5cGUgQ2xpRW52ID0gei5pbmZlcjx0eXBlb2YgY2xpRW52U2NoZW1hPjtcbiJdfQ==