@go-to-k/cdkd 0.12.0 → 0.13.0

package/README.md

@@ -428,6 +428,13 @@ cdkd destroy --all --force
 # Force-unlock a stale lock from interrupted deploy
 cdkd force-unlock MyStack
 
+# Inspect state-bucket info on demand (bucket name, region, source, schema version, stack count).
+# Routine commands (deploy / destroy / etc.) no longer print the bucket banner by default —
+# pass --verbose to surface it in their debug logs, or use this subcommand for an explicit answer.
+cdkd state info
+cdkd state info --json        # JSON output for tooling
+cdkd state info --state-bucket my-bucket  # explicit bucket; reports Source: --state-bucket flag
+
 # List stacks registered in the cdkd state bucket
 cdkd state list
 cdkd state ls --long          # include resource count, last-modified, lock status

package/dist/cli.js

@@ -970,16 +970,18 @@ function resolveApp(cliApp) {
   const cdkJson = loadCdkJson();
   return cdkJson?.app ?? void 0;
 }
-function resolveStateBucket(cliBucket) {
+function resolveStateBucketWithSource(cliBucket) {
   if (cliBucket)
-    return cliBucket;
+    return { bucket: cliBucket, source: "cli-flag" };
   const envBucket = process.env["CDKD_STATE_BUCKET"];
   if (envBucket)
-    return envBucket;
+    return { bucket: envBucket, source: "env" };
   const cdkJson = loadCdkJson();
   const cdkdContext = cdkJson?.context?.["cdkd"];
   const bucket = cdkdContext?.["stateBucket"];
-  return typeof bucket === "string" ? bucket : void 0;
+  if (typeof bucket === "string")
+    return { bucket, source: "cdk.json" };
+  return void 0;
 }
 function getDefaultStateBucketName(accountId) {
   return `cdkd-state-${accountId}`;
@@ -988,7 +990,10 @@ function getLegacyStateBucketName(accountId, region) {
   return `cdkd-state-${accountId}-${region}`;
 }
 async function resolveStateBucketWithDefault(cliBucket, region) {
-  const syncResult = resolveStateBucket(cliBucket);
+  return (await resolveStateBucketWithDefaultAndSource(cliBucket, region)).bucket;
+}
+async function resolveStateBucketWithDefaultAndSource(cliBucket, region) {
+  const syncResult = resolveStateBucketWithSource(cliBucket);
   if (syncResult)
     return syncResult;
   const logger = getLogger();
@@ -1004,14 +1009,14 @@ async function resolveStateBucketWithDefault(cliBucket, region) {
   const probe = new S3Client10({ region: "us-east-1" });
   try {
     if (await bucketExists(probe, newName)) {
-      logger.info(`State bucket: ${newName}`);
-      return newName;
+      logger.debug(`State bucket: ${newName}`);
+      return { bucket: newName, source: "default" };
     }
     if (await bucketExists(probe, legacyName)) {
       logger.warn(
         `Using legacy state bucket name '${legacyName}'. The default has changed to '${newName}'. Future cdkd versions will drop legacy support; consider migrating with cdkd state migrate-bucket (coming in a future release).`
       );
-      return legacyName;
+      return { bucket: legacyName, source: "default-legacy" };
     }
     throw new Error(
       `No cdkd state bucket found for account ${accountId}. Looked for '${newName}' (current default) and '${legacyName}' (legacy default). Run 'cdkd bootstrap' to create '${newName}'.`
@@ -29548,6 +29553,11 @@ function createForceUnlockCommand() {
 // src/cli/commands/state.ts
 import * as readline2 from "node:readline/promises";
 import { Command as Command9, Option as Option5 } from "commander";
+import {
+  GetBucketLocationCommand as GetBucketLocationCommand2,
+  GetObjectCommand as GetObjectCommand4,
+  ListObjectsV2Command as ListObjectsV2Command3
+} from "@aws-sdk/client-s3";
 init_aws_clients();
 function formatStackRef(ref) {
   return ref.region ? `${ref.stackName} (${ref.region})` : ref.stackName;
@@ -30106,8 +30116,127 @@ function createStateDestroyCommand() {
   cmd.addOption(deprecatedRegionOption);
   return cmd;
 }
+function formatBucketSource(source) {
+  switch (source) {
+    case "cli-flag":
+      return "--state-bucket flag";
+    case "env":
+      return "CDKD_STATE_BUCKET env";
+    case "cdk.json":
+      return "cdk.json (context.cdkd.stateBucket)";
+    case "default":
+      return "default (account ID from STS)";
+    case "default-legacy":
+      return "default (legacy region-suffixed name; cdkd state migrate-bucket recommended)";
+  }
+}
+async function detectBucketRegion(awsClients, bucket) {
+  try {
+    const resp = await awsClients.s3.send(new GetBucketLocationCommand2({ Bucket: bucket }));
+    const constraint = resp.LocationConstraint;
+    if (!constraint)
+      return "us-east-1";
+    if (constraint === "EU")
+      return "eu-west-1";
+    return constraint;
+  } catch {
+    return void 0;
+  }
+}
+async function listStateFileKeys(awsClients, bucket, prefix) {
+  const keys = [];
+  let continuationToken;
+  const searchPrefix = `${prefix}/`;
+  do {
+    const resp = await awsClients.s3.send(
+      new ListObjectsV2Command3({
+        Bucket: bucket,
+        Prefix: searchPrefix,
+        ...continuationToken && { ContinuationToken: continuationToken }
+      })
+    );
+    for (const obj of resp.Contents ?? []) {
+      const key = obj.Key;
+      if (typeof key === "string" && key.endsWith("/state.json")) {
+        keys.push(key);
+      }
+    }
+    continuationToken = resp.NextContinuationToken;
+  } while (continuationToken);
+  return keys;
+}
+async function readSchemaVersion(awsClients, bucket, keys) {
+  if (keys.length === 0)
+    return "unknown";
+  try {
+    const resp = await awsClients.s3.send(new GetObjectCommand4({ Bucket: bucket, Key: keys[0] }));
+    if (!resp.Body)
+      return "unknown";
+    const body = await resp.Body.transformToString();
+    const parsed = JSON.parse(body);
+    return typeof parsed.version === "number" ? parsed.version : "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+async function stateInfoCommand(options) {
+  const logger = getLogger();
+  if (options.verbose)
+    logger.setLevel("debug");
+  const awsClients = new AwsClients({
+    ...options.region && { region: options.region },
+    ...options.profile && { profile: options.profile }
+  });
+  setAwsClients(awsClients);
+  try {
+    const region = options.region || process.env["AWS_REGION"] || "us-east-1";
+    const resolved = await resolveStateBucketWithDefaultAndSource(options.stateBucket, region);
+    const bucket = resolved.bucket;
+    const prefix = options.statePrefix;
+    const stateBackend = new S3StateBackend(awsClients.s3, { bucket, prefix });
+    await stateBackend.verifyBucketExists();
+    const detectedRegion = await detectBucketRegion(awsClients, bucket);
+    const stateFileKeys = await listStateFileKeys(awsClients, bucket, prefix);
+    const schemaVersion = await readSchemaVersion(awsClients, bucket, stateFileKeys);
+    if (options.json) {
+      const json = {
+        bucket,
+        region: detectedRegion ?? null,
+        regionSource: detectedRegion ? "auto-detected" : "unknown",
+        bucketSource: resolved.source,
+        schemaVersion,
+        stackCount: stateFileKeys.length
+      };
+      process.stdout.write(`${JSON.stringify(json, null, 2)}
+`);
+      return;
+    }
+    const lines = [];
+    lines.push(`State bucket:    ${bucket}`);
+    if (detectedRegion) {
+      lines.push(`Region:          ${detectedRegion} (auto-detected via GetBucketLocation)`);
+    } else {
+      lines.push("Region:          unknown (GetBucketLocation failed or denied)");
+    }
+    lines.push(`Source:          ${formatBucketSource(resolved.source)}`);
+    lines.push(`Schema version:  ${schemaVersion}`);
+    lines.push(`Stacks:          ${stateFileKeys.length}`);
+    process.stdout.write(`${lines.join("\n")}
+`);
+  } finally {
+    awsClients.destroy();
+  }
+}
+function createStateInfoCommand() {
+  const cmd = new Command9("info").description(
+    "Show cdkd state bucket info (bucket name, region, source, schema version, stack count)"
+  ).option("--json", "Output as JSON", false).action(withErrorHandling(stateInfoCommand));
+  [...commonOptions, ...stateOptions].forEach((opt) => cmd.addOption(opt));
+  return cmd;
+}
 function createStateCommand() {
   const cmd = new Command9("state").description("Manage cdkd state stored in S3");
+  cmd.addCommand(createStateInfoCommand());
   cmd.addCommand(createStateListCommand());
   cmd.addCommand(createStateResourcesCommand());
   cmd.addCommand(createStateShowCommand());
@@ -30141,7 +30270,7 @@ function reorderArgs(argv) {
 }
 async function main() {
   const program = new Command10();
-  program.name("cdkd").description("CDK Direct - Deploy AWS CDK apps directly via SDK/Cloud Control API").version("0.12.0");
+  program.name("cdkd").description("CDK Direct - Deploy AWS CDK apps directly via SDK/Cloud Control API").version("0.13.0");
   program.addCommand(createBootstrapCommand());
   program.addCommand(createSynthCommand());
   program.addCommand(createListCommand());