import * as Command from "effect/cli/Command"; import * as Flag from "effect/cli/Flag"; import * as Effect from "effect/Effect"; import * as Option from "effect/Option"; import * as Alchemist from "../../Alchemist/index.ts"; import * as Interaction from "../../Interaction.ts"; import { Cli } from "../../Report.ts"; import { renderApply } from "../../Report.ts"; import { planDecisionScreen } from "../components/view/PlanDecision.tsx"; import { stackOutputsView } from "../components/view/StackOutputs.tsx"; import { exitDeclined } from "./errors.ts"; import { configPath, dryRun as dryRunFlag, envFile, force, include, exclude, validateSelectionOptions, optionalConfig, profile, resolveStackArgs, stage, yes, } from "./flags.ts"; import { instrumentCommand } from "./instrument.ts"; import { renderPlanning } from "./render.ts"; interface StackCommandOptions { readonly main: string; readonly stage: string; readonly envFile: Option.Option; readonly profile?: string; readonly dryRun?: boolean; readonly force?: boolean; readonly include?: ReadonlyArray; readonly exclude?: ReadonlyArray; readonly yes?: boolean; readonly destroy?: boolean; readonly adopt?: boolean; readonly detailed?: boolean; readonly detectDrift?: boolean; } const stackSpanAttrs = (args: StackCommandOptions) => ({ "alchemy.stage": args.stage, "alchemy.profile": args.profile, "alchemy.main": args.main, "alchemy.dry_run": !!args.dryRun, "alchemy.force": !!args.force, "alchemy.destroy": !!args.destroy, "alchemy.adopt": !!args.adopt, "alchemy.detailed": !!args.detailed, "alchemy.detect_drift": !!args.detectDrift, }); const adopt = Flag.Boolean("adopt").pipe( Flag.withDescription( "Adopt pre-existing cloud resources that conflict with this stack instead of failing. " + "Useful for re-importing infrastructure into a fresh state store.", ), Flag.withDefault(false), ); const detailed = Flag.Boolean("detailed").pipe( Flag.withDescription("Show declared resource properties as YAML"), Flag.withDefault(false), ); const detectDrift = Flag.Boolean("detect-drift").pipe( Flag.withDescription("Detect infrastructure drift and offer to repair it before deploying"), Flag.withDefault(false), ); const detectAndMaybeRepairDrift = Effect.fn(function* ( scanDrift: Effect.Effect, options: { readonly stage: string; readonly yes?: boolean; readonly detailed?: boolean; readonly dryRun?: boolean; }, ) { const cli = yield* Cli; const snapshot = yield* scanDrift.pipe( renderPlanning({ operation: "Drift", stage: options.stage, computingLabel: "Checking drift", readyLabel: "Drift check complete", }), ); if (!Alchemist.Drift.hasDrift(snapshot)) return true; if (options.dryRun) { yield* cli.displayPlan(snapshot.native, { detailed: options.detailed, stage: options.stage, }); return true; } let decision: "repair" | "deploy" | "cancel" = options.yes ? "repair" : "cancel"; if (!options.yes) { const terminal = yield* Interaction.Interaction; if (terminal.terminal.input) { decision = yield* terminal.prompt .screen( planDecisionScreen({ plan: snapshot.native, message: "Drift detected", choices: [ { value: "repair" as const, label: "Repair and Deploy", }, { value: "deploy" as const, label: "Deploy without Repair", }, { value: "cancel" as const, label: "Cancel", }, ], initialValue: "repair" as const, }), ) .pipe(Effect.catchTag("TerminalCancelled", () => Effect.succeed("cancel" as const))); } else { yield* cli.displayPlan(snapshot.native, { detailed: options.detailed, stage: options.stage, }); yield* Interaction.warning( "Drift detected in a non-interactive terminal. Re-run with --yes to repair and deploy.", ); } } if (decision === "repair") { yield* Alchemist.Drift.execute(snapshot).pipe( renderApply(snapshot.native, { detailed: options.detailed, stage: options.stage, }), ); } return decision !== "cancel"; }); const runStack = Effect.fn(function* (options: StackCommandOptions) { yield* validateSelectionOptions(options); const cli = yield* Cli; const display = { detailed: options.detailed, stage: options.stage }; const buildOptions = { stage: options.stage, profile: options.profile, envFile: Option.getOrUndefined(options.envFile), adopt: options.adopt, updateStateStore: options.yes, }; const stack = Alchemist.importStack(options.main); const operation = options.destroy ? "Destroy" : options.dryRun ? "Plan" : "Deploy"; const withPlanningProgress = renderPlanning({ operation, stage: options.stage, }); if (options.detectDrift && !options.destroy) { // The drift check closes its build before the deploy builds again: a // remote state store holds one lease per stage per build. const proceed = yield* detectAndMaybeRepairDrift( Effect.flatMap(stack, (stack) => Alchemist.Drift.scan({ ...buildOptions, stack })), options, ).pipe(Effect.scoped); if (!proceed) { yield* Interaction.info("Deploy aborted: drift was detected and not approved."); return yield* exitDeclined; } } const snapshot = yield* Effect.flatMap(stack, (stack) => Alchemist.plan( options.destroy ? { ...buildOptions, stack, operation: "destroy" } : { ...buildOptions, stack, operation: "deploy", force: options.force, include: options.include, exclude: options.exclude, }, ), ).pipe(withPlanningProgress); if (options.dryRun) { return yield* cli.displayPlan(snapshot.native, display); } if (!options.yes && Alchemist.hasChanges(snapshot)) { const approved = yield* cli.approvePlan(snapshot.native, display).pipe( Effect.tap((approved) => approved ? Effect.void : Interaction.info(`${operation} aborted: plan declined.`), ), Effect.catchTag("NonInteractiveTerminal", () => Interaction.warning( `Cannot prompt for approval in a non-interactive terminal. Nothing was changed — re-run with --yes to ${operation.toLowerCase()}.`, ).pipe(Effect.as(false)), ), ); if (!approved) return yield* exitDeclined; } const result = yield* Alchemist.apply(snapshot).pipe(renderApply(snapshot.native, display)); if (result !== undefined) { const kit = yield* Interaction.Interaction; yield* kit.output.print(stackOutputsView(result)); } }); export const deployCommand = Command.make( "deploy", { dryRun: dryRunFlag, force, include, exclude, config: optionalConfig, configPath, envFile, stage, yes, profile, adopt, detailed, detectDrift, }, (args) => resolveStackArgs("live")(args).pipe( Effect.flatMap(instrumentCommand("deploy", stackSpanAttrs)(runStack)), ), ); export const destroyCommand = Command.make( "destroy", { include, exclude, dryRun: dryRunFlag, config: optionalConfig, configPath, envFile, stage, yes, profile, }, (args) => resolveStackArgs("live")(args).pipe( Effect.flatMap( instrumentCommand( "destroy", stackSpanAttrs, )((options) => runStack({ ...options, destroy: true, }), ), ), ), ); export const planCommand = Command.make( "plan", { include, exclude, config: optionalConfig, configPath, envFile, stage, profile, adopt, detailed, }, (args) => resolveStackArgs("live")(args).pipe( Effect.flatMap( instrumentCommand( "plan", stackSpanAttrs, )((options) => runStack({ ...options, // plan is the same as deploy with dryRun always set to true dryRun: true, }), ), ), ), );