@go-to-k/cdkd 0.162.3 → 0.164.0

package/dist/cli.js

@@ -37,6 +37,8 @@ import { AddTagsToResourceCommand as AddTagsToResourceCommand$1, CreateDBCluster
 import { Command, Option } from "commander";
 import { writeFileSync as writeFileSync$1 } from "fs";
 import { join as join$1 } from "path";
+import * as readline$1 from "node:readline/promises";
+import readline from "node:readline/promises";
 import * as zlib from "node:zlib";
 import { ApplicationAutoScalingClient, DeleteScalingPolicyCommand, DeregisterScalableTargetCommand, DescribeScalableTargetsCommand, DescribeScalingPoliciesCommand, PutScalingPolicyCommand, RegisterScalableTargetCommand } from "@aws-sdk/client-application-auto-scaling";
 import { ApiGatewayV2Client, CreateApiCommand, CreateAuthorizerCommand as CreateAuthorizerCommand$1, CreateIntegrationCommand, CreateRouteCommand as CreateRouteCommand$1, CreateStageCommand as CreateStageCommand$1, DeleteApiCommand, DeleteAuthorizerCommand as DeleteAuthorizerCommand$1, DeleteIntegrationCommand, DeleteRouteCommand as DeleteRouteCommand$1, DeleteStageCommand as DeleteStageCommand$1, GetApiCommand, GetApisCommand, GetAuthorizerCommand as GetAuthorizerCommand$1, GetIntegrationCommand, GetRouteCommand, GetStageCommand as GetStageCommand$1, NotFoundException as NotFoundException$3, UpdateApiCommand, UpdateAuthorizerCommand as UpdateAuthorizerCommand$1, UpdateIntegrationCommand, UpdateRouteCommand, UpdateStageCommand as UpdateStageCommand$1 } from "@aws-sdk/client-apigatewayv2";
@@ -59,7 +61,6 @@ import { BatchGetProjectsCommand, CodeBuildClient, CreateProjectCommand, DeleteP
 import { CreateVectorBucketCommand, DeleteIndexCommand, DeleteVectorBucketCommand, GetVectorBucketCommand, ListIndexesCommand, ListTagsForResourceCommand as ListTagsForResourceCommand$18, ListVectorBucketsCommand, S3VectorsClient } from "@aws-sdk/client-s3vectors";
 import { CreateNamespaceCommand, CreateTableBucketCommand, CreateTableCommand as CreateTableCommand$2, DeleteNamespaceCommand as DeleteNamespaceCommand$1, DeleteTableBucketCommand, DeleteTableCommand as DeleteTableCommand$2, GetTableBucketCommand, GetTableCommand as GetTableCommand$1, ListNamespacesCommand as ListNamespacesCommand$1, ListTableBucketsCommand, ListTablesCommand as ListTablesCommand$1, ListTagsForResourceCommand as ListTagsForResourceCommand$19, NotFoundException as NotFoundException$5, S3TablesClient } from "@aws-sdk/client-s3tables";
 import { AttachLoadBalancerTargetGroupsCommand, AttachLoadBalancersCommand, AttachTrafficSourcesCommand, AutoScalingClient, CreateAutoScalingGroupCommand, CreateOrUpdateTagsCommand, DeleteAutoScalingGroupCommand, DeleteLifecycleHookCommand, DeleteNotificationConfigurationCommand, DeleteTagsCommand as DeleteTagsCommand$1, DescribeAutoScalingGroupsCommand, DescribeLifecycleHooksCommand, DescribeNotificationConfigurationsCommand, DescribeTrafficSourcesCommand, DetachLoadBalancerTargetGroupsCommand, DetachLoadBalancersCommand, DetachTrafficSourcesCommand, DisableMetricsCollectionCommand, EnableMetricsCollectionCommand, PutLifecycleHookCommand, PutNotificationConfigurationCommand, UpdateAutoScalingGroupCommand } from "@aws-sdk/client-auto-scaling";
-import * as readline from "node:readline/promises";
 import { Document, Pair, Scalar, YAMLMap, YAMLSeq, parse as parse$1, stringify } from "yaml";
 import { mkdir, mkdtemp } from "node:fs/promises";
 import { Readable } from "node:stream";
@@ -1004,9 +1005,12 @@ const MULTI_REGION_RECREATE_BLOCKED_TYPES = new Set(["AWS::DynamoDB::GlobalTable
 * Cheap, synchronous read of the resource's recorded properties only.
 * For `AWS::S3::Bucket` this returns `null` — the live `ListObjectsV2`
 * probe to distinguish empty buckets (safe to recreate) from
-* non-empty (data loss) needs an S3 client + an AWS round-trip and is
-* deferred to a follow-up issue (v1 sync-defers; an `--force-stateful-
-* recreation` is recommended for any potentially-non-empty S3 target).
+* non-empty (data loss) lives in
+* `src/deployment/recreate-targets.ts#probeStatefulRecreateTargetsAsync`
+* (issue [#648]) and runs after this sync first-cut. Sync callers can
+* still treat `null` as "not stateful" — the deploy command does both
+* passes back-to-back; only callers that explicitly opt out of the
+* async probe need to assume conservative "stateful" semantics.
 *
 * Returns the {@link StatefulReason} when the type is stateful (or
 * `null` for non-stateful types).
@@ -1038,11 +1042,47 @@ function renderStatefulReason(reason) {
 //#endregion
 //#region src/deployment/recreate-targets.ts
 /**
+* Pre-flight validation for `--recreate-via-cc-api <LogicalId>` deploy
+* flag (issue [#615]).
+*
+* Three things to validate before the deploy engine acts on the user's
+* recreate list:
+*
+*   1. Every named logical id MUST exist in the synth template. A typo
+*      should fail fast, not silently skip.
+*   2. Every named logical id MUST exist in cdkd state (the recreate
+*      operation requires an existing physical resource to destroy +
+*      recreate). A logical id in the template but absent from state
+*      is a CREATE on the next deploy regardless — recreate is a
+*      no-op for fresh deploys and should error out with a clear
+*      message rather than silently apply.
+*   3. Stateful-resource guard: every named target whose resource type
+*      is in {@link STATEFUL_TYPES} (or conditionally stateful — S3
+*      bucket with objects, LogGroup with retention) MUST be matched
+*      by an explicit `--force-stateful-recreation` flag. The sync
+*      first-cut runs from the recorded properties alone; the live
+*      `s3:ListObjectsV2` probe (issue [#648]) promotes a `null`
+*      reason to `'has-objects'` when a bucket actually contains data.
+*   4. Multi-region refusal: every named target whose resource type
+*      is in {@link MULTI_REGION_RECREATE_BLOCKED_TYPES} (e.g.
+*      `AWS::DynamoDB::GlobalTable`) is refused outright. Out of
+*      scope for v1; no `--force-stateful-recreation` bypass since
+*      this is a structural limitation, not a data-loss footgun.
+*
+* Plus one cross-flag invariant: `--recreate-via-cc-api MyLambda`
+* combined with `--allow-unsupported-properties AWS::Lambda::Function:LoggingConfig`
+* on a resource whose template carries `LoggingConfig` is **ambiguous
+* intent** — does the user want SDK + silent drop, or CC migration?
+* Fail fast and let the user pick one strategy per resource.
+*/
+/**
 * Plan-time validation of the user's recreate-via-cc-api list.
 *
-* Pure with respect to AWS — does NOT probe S3 bucket emptiness. The
-* S3 conditional check is deferred to a follow-up issue (the live
-* `s3:ListObjectsV2` probe is out of scope for v1).
+* Pure with respect to AWS — does NOT probe S3 bucket emptiness. Wrap
+* the result with {@link probeAndRevalidateStateful} to promote S3
+* targets' `statefulReason` via a live `s3:ListObjectsV2` round-trip
+* before rendering errors. The deploy command does this; the validator
+* itself stays sync so unit tests don't need an S3 mock.
 *
 * Input order is preserved; duplicate logical ids in the user's input
 * are deduplicated.
@@ -1137,6 +1177,140 @@ function renderRecreateTargetsErrors(validation) {
 	}
 	return lines.length > 0 ? lines.join("\n") : null;
 }
+/**
+* Async S3 object probe (issue [#648]).
+*
+* For every `AWS::S3::Bucket` target whose sync {@link StatefulReason}
+* is `null` (the sync map defers — see {@link isStatefulRecreateTargetSync}),
+* issues a single-page `ListObjectVersions(MaxKeys=1)` against the
+* bucket's recorded physical id. When the bucket has at least one
+* current object, prior version, OR delete-marker, promotes the
+* target's `statefulReason` to `'has-objects'`.
+*
+* Uses `ListObjectVersions` rather than `ListObjectsV2` so the probe
+* mirrors the s3-bucket-provider's `emptyBucket` view: a versioned
+* bucket whose current keys have all been soft-deleted (so
+* `ListObjectsV2.KeyCount === 0`) still holds prior versions +
+* delete-markers that the destroy + recreate cycle would lose. Using
+* the same listing API as the provider ensures the probe and the
+* destroy path agree on "empty".
+*
+* **Soft-fail on probe errors**: if `ListObjectVersions` throws
+* (permission denied, bucket-not-found mid-flight, transient network
+* error), logs a warn and leaves the target's `statefulReason` at the
+* sync result (`null`). The user can decide to proceed without the
+* probe by passing `--force-stateful-recreation`.
+*
+* Returns a NEW array of targets; the input is not mutated. Non-S3
+* targets and S3 targets whose sync reason is already non-null are
+* passed through unchanged.
+*/
+async function probeStatefulRecreateTargetsAsync(targets, s3Client, logger = getLogger().child("recreate-targets")) {
+	const promoted = [];
+	for (const target of targets) {
+		if (target.resourceType !== "AWS::S3::Bucket" || target.statefulReason !== null) {
+			promoted.push({ ...target });
+			continue;
+		}
+		try {
+			const result = await s3Client.send(new ListObjectVersionsCommand({
+				Bucket: target.physicalId,
+				MaxKeys: 1
+			}));
+			const hasVersions = (result.Versions?.length ?? 0) > 0;
+			const hasDeleteMarkers = (result.DeleteMarkers?.length ?? 0) > 0;
+			if (hasVersions || hasDeleteMarkers) promoted.push({
+				...target,
+				statefulReason: "has-objects"
+			});
+			else promoted.push({ ...target });
+		} catch (e) {
+			logger.warn(`--recreate-via-cc-api: live S3 probe failed for ${target.logicalId} (bucket ${target.physicalId}); leaving stateful guard at the sync result. If the bucket might be non-empty, re-run with --force-stateful-recreation. Underlying error: ${e instanceof Error ? e.message : String(e)}`);
+			promoted.push({ ...target });
+		}
+	}
+	return promoted;
+}
+/**
+* Async re-validation of the stateful-guard slice of a
+* {@link RecreateTargetsValidation}, after promoting S3 bucket reasons
+* via {@link probeStatefulRecreateTargetsAsync}.
+*
+* Skips the probe entirely when `forceStatefulRecreation: true` — the
+* sync validation already omits the blocked list in that case, and
+* skipping avoids an unnecessary AWS round-trip (plus permission-denied
+* warn-and-skip cycle on low-privilege CI roles).
+*
+* Returns a NEW validation; the input is not mutated. Non-stateful
+* categories (`unknownLogicalIds` / `missingFromState` /
+* `ambiguousIntent` / `blockedMultiRegionTargets`) are preserved verbatim.
+*/
+async function probeAndRevalidateStateful(input) {
+	if (input.forceStatefulRecreation) return input.validation;
+	const promoted = await probeStatefulRecreateTargetsAsync(input.validation.targets, input.s3Client);
+	const blockedStatefulTargets = promoted.filter((t) => t.statefulReason !== null);
+	return {
+		...input.validation,
+		targets: promoted,
+		blockedStatefulTargets
+	};
+}
+
+//#endregion
+//#region src/cli/commands/recreate-confirm-prompt.ts
+/**
+* Interactive confirmation prompt for `cdkd deploy --recreate-via-cc-api`
+* (issue [#649]).
+*
+* Mirror of {@link ../prefix-migration-check.ts}'s `promptMigrationConfirm`
+* but for the recreate-via-cc-api destroy+recreate cycle:
+*
+*   - `opts.yes` (CDK CLI parity `-y` / `--yes`) skips the prompt and
+*     prints the per-target plan as a `WARN` block (the existing v1
+*     surface). CI use case.
+*   - When `opts.yes` is false, the prompt fires after the per-target
+*     plan. Default is `N` because the side effect is destructive
+*     (a per-resource destroy + recreate cycle).
+*   - Non-TTY guard: if `opts.yes` is false AND stdin is not a TTY,
+*     throws with an actionable message rather than hanging or
+*     silently declining. CI runs without `--yes` would otherwise look
+*     like a successful skipped-deploy.
+*
+* The per-target plan surfaces a **DATA LOSS** prefix for stateful
+* targets (those with a non-null `statefulReason` after the live
+* `s3:ListObjectsV2` probe — see issue [#648]); these reached pre-flight
+* only because the user opted in with `--force-stateful-recreation`,
+* so the prompt's **DATA LOSS** wording is the third "stop and think"
+* moment.
+*/
+async function promptRecreateConfirm(input) {
+	if (input.targets.length === 0) return true;
+	const logger = getLogger();
+	logger.warn("");
+	logger.warn(`--recreate-via-cc-api will destroy + recreate ${input.targets.length} resource(s) via Cloud Control API on stack ${input.stackName}:`);
+	for (const t of input.targets) {
+		const stateful = t.statefulReason !== null;
+		const dataLossPrefix = stateful ? "**DATA LOSS** " : "";
+		const stateNote = stateful ? ` — stateful (${t.statefulReason}); --force-stateful-recreation acknowledged` : "";
+		logger.warn(`  - ${dataLossPrefix}${t.logicalId} (${t.resourceType})${stateNote}`);
+		if (stateful) logger.warn(`    DATA: all data in ${t.logicalId} will be lost (no automatic data migration)`);
+	}
+	logger.warn("  The destroy + recreate cycle is per-resource; sibling resources are unaffected. Downstream consumers of any recreated resource's outputs (Fn::GetStackOutput / Fn::ImportValue) will need a re-deploy to see the new physical id.");
+	if (input.yes) return true;
+	if (process.stdin.isTTY !== true) throw new Error("--recreate-via-cc-api confirm prompt cannot run in a non-interactive environment. Pass --yes / -y to confirm the destroy + recreate cycle, or run the deploy from a real terminal.");
+	const rl = readline.createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	try {
+		const trimmed = (await rl.question("\nContinue? (y/N): ")).trim().toLowerCase();
+		if (trimmed === "y" || trimmed === "yes") return true;
+		logger.info("Deploy cancelled — no resources modified.");
+		return false;
+	} finally {
+		rl.close();
+	}
+}
 
 //#endregion
 //#region src/state/export-index-store.ts
@@ -32334,7 +32508,7 @@ async function runDestroyForStack(stackName, state, ctx) {
 	for (const [logicalId, resource] of Object.entries(state.resources)) logger.info(`  - ${logicalId} (${resource.resourceType})`);
 	const protectedCount = ctx.removeProtection ? countProtectedResources(state) : 0;
 	if (!ctx.skipConfirmation) {
-		const rl = readline.createInterface({
+		const rl = readline$1.createInterface({
 			input: process.stdin,
 			output: process.stdout
 		});
@@ -33405,7 +33579,7 @@ async function promptMigrationConfirm(renames, opts) {
 	logger.warn("These resources will be REPLACED because the new naming convention drops the stack-name prefix.");
 	if (opts.yes) return true;
 	if (process.stdin.isTTY !== true) throw new Error("--no-prefix-user-supplied-names migration confirm prompt cannot run in a non-interactive environment. Pass --yes / -y to confirm the REPLACEMENT, or run the deploy from a real terminal.");
-	const rl = readline.createInterface({
+	const rl = readline$1.createInterface({
 		input: process.stdin,
 		output: process.stdout
 	});
@@ -33597,30 +33771,33 @@ async function deployCommand(stacks, options) {
 				let recreateViaCcApiTargets;
 				if (options.recreateViaCcApi?.length) {
 					const stateForRecreateCheck = await stackStateBackend.getState(stackInfo.stackName, stackRegion);
-					const validation = validateRecreateTargets({
-						template: stackInfo.template,
-						state: stateForRecreateCheck?.state ?? {
-							version: 7,
-							stackName: stackInfo.stackName,
-							region: stackRegion,
-							resources: {},
-							outputs: {},
-							lastModified: Date.now()
-						},
-						recreateViaCcApi: options.recreateViaCcApi,
-						allowUnsupportedProperties: new Set(options.allowUnsupportedProperties ?? []),
+					const validation = await probeAndRevalidateStateful({
+						validation: validateRecreateTargets({
+							template: stackInfo.template,
+							state: stateForRecreateCheck?.state ?? {
+								version: 7,
+								stackName: stackInfo.stackName,
+								region: stackRegion,
+								resources: {},
+								outputs: {},
+								lastModified: Date.now()
+							},
+							recreateViaCcApi: options.recreateViaCcApi,
+							allowUnsupportedProperties: new Set(options.allowUnsupportedProperties ?? []),
+							forceStatefulRecreation: options.forceStatefulRecreation ?? false
+						}),
+						s3Client: stackAwsClients.s3,
 						forceStatefulRecreation: options.forceStatefulRecreation ?? false
 					});
 					const errorBlock = renderRecreateTargetsErrors(validation);
 					if (errorBlock) throw new CdkdError(errorBlock, "RECREATE_VIA_CC_API_INVALID");
 					recreateViaCcApiTargets = new Set(validation.targets.map((t) => t.logicalId));
 					if (recreateViaCcApiTargets.size > 0) {
-						logger.warn(`--recreate-via-cc-api will destroy + recreate ${recreateViaCcApiTargets.size} resource(s) via Cloud Control API on stack ${stackInfo.stackName}:`);
-						for (const t of validation.targets) {
-							const stateNote = t.statefulReason !== null ? ` ⚠ stateful (${t.statefulReason}) — --force-stateful-recreation acknowledged` : "";
-							logger.warn(`  - ${t.logicalId} (${t.resourceType})${stateNote}`);
-						}
-						logger.warn("  The destroy + recreate cycle is per-resource; sibling resources are unaffected. Downstream consumers of any recreated resource's outputs (Fn::GetStackOutput / Fn::ImportValue) will need a re-deploy to see the new physical id.");
+						if (!await promptRecreateConfirm({
+							stackName: stackInfo.stackName,
+							targets: validation.targets,
+							yes: options.yes ?? false
+						})) return;
 					}
 				}
 				const deployEngineOptions = {
@@ -34513,7 +34690,7 @@ async function walkCfnStackTree(stackName, physicalId, cfnClient) {
 	};
 }
 async function confirmPrompt$5(prompt) {
-	const rl = readline.createInterface({
+	const rl = readline$1.createInterface({
 		input: process.stdin,
 		output: process.stdout
 	});
@@ -35793,7 +35970,7 @@ async function runWithConcurrency(tasks, concurrency) {
 	await Promise.all(workers);
 }
 async function confirmPrompt$4(prompt) {
-	const rl = readline.createInterface({
+	const rl = readline$1.createInterface({
 		input: process.stdin,
 		output: process.stdout
 	});
@@ -36762,7 +36939,7 @@ function stringifyForAudit(value) {
 	return JSON.stringify(value);
 }
 async function confirmPrompt$3(prompt) {
-	const rl = readline.createInterface({
+	const rl = readline$1.createInterface({
 		input: process.stdin,
 		output: process.stdout
 	});
@@ -37251,7 +37428,7 @@ async function emptyBucketAllVersions(s3, bucket) {
 	} while (keyMarker || versionIdMarker);
 }
 async function confirmPrompt$2(prompt) {
-	const rl = readline.createInterface({
+	const rl = readline$1.createInterface({
 		input: process.stdin,
 		output: process.stdout
 	});
@@ -39668,7 +39845,7 @@ function printNextSteps(args) {
 	logger.info("");
 }
 async function confirmPrompt$1(prompt) {
-	const rl = readline.createInterface({
+	const rl = readline$1.createInterface({
 		input: process.stdin,
 		output: process.stdout
 	});
@@ -40247,7 +40424,7 @@ async function stateOrphanCommand(stackArgs, options) {
 			if (!options.yes && !options.force) {
 				const targetList = targets.map((t) => formatStackRef(t)).join(", ");
 				process.stdout.write(`\nWARNING: This removes cdkd's state record for [${targetList}] only. AWS resources will NOT be deleted.\nUse 'cdkd destroy ${stackName}' if you want to delete the actual resources.\n\n`);
-				const rl = readline.createInterface({
+				const rl = readline$1.createInterface({
 					input: process.stdin,
 					output: process.stdout
 				});
@@ -40344,7 +40521,7 @@ async function stateDestroyCommand(stackArgs, options) {
 			process.stdout.write(`\nWARNING: This destroys ${stackNames.length} stack(s) and removes their state records:\n`);
 			for (const name of stackNames) process.stdout.write(`  - ${name}\n`);
 			process.stdout.write("\n");
-			const rl = readline.createInterface({
+			const rl = readline$1.createInterface({
 				input: process.stdin,
 				output: process.stdout
 			});
@@ -40807,7 +40984,7 @@ async function refreshObservedForStack(stackName, region, stateBackend, lockMana
 	}
 }
 async function confirmRefresh(prompt) {
-	const rl = readline.createInterface({
+	const rl = readline$1.createInterface({
 		input: process.stdin,
 		output: process.stdout
 	});
@@ -41423,7 +41600,7 @@ function formatOutcome(outcome) {
 	}
 }
 async function confirmPrompt(prompt) {
-	const rl = readline.createInterface({
+	const rl = readline$1.createInterface({
 		input: process.stdin,
 		output: process.stdout
 	});
@@ -60328,7 +60505,7 @@ function reorderArgs(argv) {
 */
 async function main() {
 	const program = new Command();
-	program.name("cdkd").description("CDK Direct - Deploy AWS CDK apps directly via SDK/Cloud Control API").version("0.162.3");
+	program.name("cdkd").description("CDK Direct - Deploy AWS CDK apps directly via SDK/Cloud Control API").version("0.164.0");
 	program.addCommand(createBootstrapCommand());
 	program.addCommand(createSynthCommand());
 	program.addCommand(createListCommand());