import { Command, Flag } from "effect/cli"; import * as Clock from "effect/Clock"; import * as Console from "effect/Console"; import * as Duration from "effect/Duration"; 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 { renderNukeScan, renderNukeDelete, reviewNuke } from "../components/view/Nuke.tsx"; import { formatElapsed } from "../Format.ts"; import { exitDeclined, UserInputError } from "./errors.ts"; import { configPath, envFile, optionalConfig, profile, resolveConfig, yes } from "./flags.ts"; import { instrumentCommand } from "./instrument.ts"; const includeFlag = Flag.String("include").pipe( Flag.withDescription("Glob of provider IDs to include (repeatable)"), Flag.atLeast(0), ); const excludeFlag = Flag.String("exclude").pipe( Flag.withDescription("Glob of provider IDs to exclude (repeatable)"), Flag.atLeast(0), ); const filterFlag = Flag.String("filter").pipe( Flag.withDescription( "JavaScript expression evaluated with resource in scope; matching resources are excluded from deletion (repeatable)", ), Flag.atLeast(0), ); const concurrencyFlag = Flag.Int("concurrency").pipe( Flag.withDescription("Maximum providers processed in parallel; 0 is unbounded"), Flag.withDefault(16), Flag.map((value): number | "unbounded" => (value <= 0 ? "unbounded" : value)), ); const timeoutFlag = Flag.Int("timeout").pipe( Flag.withDescription("Per-provider delete timeout in seconds"), Flag.withDefault(120), Flag.map(Duration.seconds), ); const scanTimeoutFlag = Flag.Int("scan-timeout").pipe( Flag.withDescription("Per-provider scan (list) timeout in seconds"), Flag.withDefault(60), Flag.map(Duration.seconds), ); const independentFlag = Flag.Boolean("independent").pipe( Flag.withDescription("Retry each resource independently"), Flag.withDefault(false), ); const retriesFlag = Flag.Int("retries").pipe( Flag.withDescription("Independent retries per resource"), Flag.withDefault(10), ); const localFlag = Flag.Boolean("local").pipe( Flag.withDescription("Target only locally emulated providers"), Flag.withDefault(false), ); const dryRunFlag = Flag.Boolean("dry-run").pipe( Flag.withDescription("Scan and show targets without deleting"), Flag.withDefault(false), ); // A broken filter must abort the nuke, not silently widen the kill list: // compile and evaluation errors both fail the command before any deletion. const compileFilter = (expression: string) => Effect.try({ try: () => // oxlint-disable-next-line typescript/no-implied-eval -- --filter is a user-supplied JS expression by design new Function("scope", `with (scope) { return (${expression}); }`) as (scope: { resource: Record; }) => unknown, catch: (cause) => new UserInputError({ message: `--filter expression ${JSON.stringify(expression)} failed to compile: ${cause instanceof Error ? cause.message : String(cause)}`, }), }).pipe( Effect.map( (predicate) => (resource: Record) => Effect.try({ try: () => Boolean(predicate({ resource })), catch: (cause) => new UserInputError({ message: `--filter expression ${JSON.stringify(expression)} threw while evaluating a resource: ${cause instanceof Error ? cause.message : String(cause)}`, }), }), ), ); const nukeCommand = Command.make( "nuke", { config: optionalConfig, configPath, envFile, profile, yes, dryRun: dryRunFlag, concurrency: concurrencyFlag, timeout: timeoutFlag, scanTimeout: scanTimeoutFlag, independent: independentFlag, retries: retriesFlag, include: includeFlag, exclude: excludeFlag, filter: filterFlag, local: localFlag, }, (args) => resolveConfig(args).pipe( Effect.flatMap( instrumentCommand("unsafe.nuke", (args: { profile: string | undefined; main: string }) => ({ "alchemy.profile": args.profile ?? "", "alchemy.main": args.main, }))( Effect.fn(function* (args) { const scan = yield* Effect.flatMap(Alchemist.importStack(args.main), (stack) => Alchemist.Nuke.scan({ stack, profile: args.profile, envFile: Option.getOrUndefined(args.envFile), dev: args.local, include: args.include, exclude: args.exclude, concurrency: args.concurrency, providerTimeoutSeconds: Duration.toSeconds(args.scanTimeout), }), ).pipe(renderNukeScan()); const predicates = yield* Effect.forEach(args.filter, compileFilter); const targets: Array<(typeof scan.resources)[number]> = []; for (const resource of scan.resources) { const matches = yield* Effect.forEach(predicates, (predicate) => predicate({ ...resource.attributes, Type: resource.providerId, LogicalId: resource.displayName, }), ); if (!matches.some(Boolean)) targets.push(resource); } if (targets.length === 0) { yield* Interaction.info("Nothing to delete."); return; } const approved = yield* reviewNuke(targets, { mode: scan.mode, yes: args.yes, dryRun: args.dryRun, }); if (!approved) { yield* Interaction.info("Aborted."); return yield* exitDeclined; } if (args.dryRun) { yield* Console.log("Dry run complete: nothing was deleted."); return; } const deleteStartedAt = yield* Clock.currentTimeMillis; const result = yield* Alchemist.Nuke.execute({ scan, resources: targets, strategy: args.independent ? { type: "independent", retries: args.retries } : { type: "coordinated" }, concurrency: args.concurrency, providerTimeoutSeconds: Duration.toSeconds(args.timeout), }).pipe(renderNukeDelete(targets, scan.mode)); const deleteElapsed = (yield* Clock.currentTimeMillis) - deleteStartedAt; yield* Interaction.success( `Deleted ${result.deleted.length} resource(s) over ${result.passes} pass(es) (${formatElapsed(deleteElapsed)}).`, ); if (result.held.length > 0) { yield* Interaction.warning(`${result.held.length} resource(s) were held back.`); } if (result.failed.length > 0) { yield* Interaction.error(`${result.failed.length} resource(s) could not be deleted.`); } }), ), ), ), ).pipe( Command.withDescription("Enumerate resources across the stack providers and delete them"), Command.unlisted, ); export const unsafeCommand = Command.make("unsafe", {}).pipe( Command.withDescription("Dangerous, irreversible operations"), Command.withSubcommands([nukeCommand]), Command.unlisted, );