@go-to-k/cdkd 0.15.0 → 0.16.1

package/dist/cli.js

@@ -1008,15 +1008,31 @@ async function resolveStateBucketWithDefaultAndSource(cliBucket, region) {
   const legacyName = getLegacyStateBucketName(accountId, region);
   const probe = new S3Client11({ region: "us-east-1" });
   try {
-    if (await bucketExists(probe, newName)) {
+    const newExists = await bucketExists(probe, newName);
+    const legacyExists = await bucketExists(probe, legacyName);
+    if (newExists && legacyExists) {
+      const newHasState = await bucketHasAnyState(probe, newName);
+      if (!newHasState) {
+        const legacyHasState = await bucketHasAnyState(probe, legacyName);
+        if (legacyHasState) {
+          logger.warn(
+            `Both '${newName}' (new default) and '${legacyName}' (legacy default) exist, but the new bucket is empty and the legacy one has state. Reading from legacy. Run \`cdkd state migrate --region ${region}\` to copy the state into the new bucket and stop seeing this warning.`
+          );
+          return { bucket: legacyName, source: "default-legacy" };
+        }
+      }
+      logger.debug(`State bucket: ${newName}`);
+      return { bucket: newName, source: "default" };
+    }
+    if (newExists) {
       logger.debug(`State bucket: ${newName}`);
       return { bucket: newName, source: "default" };
     }
-    if (await bucketExists(probe, legacyName)) {
+    if (legacyExists) {
       logger.warn(
         `Using legacy state bucket name '${legacyName}'. The default has changed to '${newName}'. To migrate, run:
 
-    cdkd state migrate-bucket --region ${region}
+    cdkd state migrate --region ${region}
 
 (add --remove-legacy to delete the legacy bucket after a successful copy; legacy support will be dropped in a future release.)`
       );
@@ -1029,6 +1045,21 @@ async function resolveStateBucketWithDefaultAndSource(cliBucket, region) {
     probe.destroy();
   }
 }
+async function bucketHasAnyState(client, bucketName) {
+  const { ListObjectsV2Command: ListObjectsV2Command5 } = await import("@aws-sdk/client-s3");
+  try {
+    const resp = await client.send(
+      new ListObjectsV2Command5({
+        Bucket: bucketName,
+        Prefix: "cdkd/",
+        MaxKeys: 1
+      })
+    );
+    return (resp.KeyCount ?? 0) > 0;
+  } catch {
+    return true;
+  }
+}
 async function bucketExists(client, bucketName) {
   const { HeadBucketCommand: HeadBucketCommand5 } = await import("@aws-sdk/client-s3");
   try {
@@ -7010,6 +7041,60 @@ Error: ${err.message || "Unknown error"}`,
     }
     return resourceType.startsWith("AWS::");
   }
+  /**
+   * Adopt an already-deployed resource into cdkd state via Cloud Control API.
+   *
+   * Strategy: explicit-override only.
+   *   - With `knownPhysicalId` (from `--resource <id>=<physicalId>` or
+   *     `--resource-mapping`): call `GetResource(TypeName, Identifier)`,
+   *     parse `ResourceModel` (returned as a JSON string by CC API), and
+   *     return its keys as `attributes`.
+   *   - Without `knownPhysicalId`: return `null`. CC API has no efficient
+   *     `aws:cdk:path`-tag lookup — `ListResources` returns identifiers
+   *     only, so tag lookup would require one `GetResource` per resource
+   *     in the account, plus per-service tag-API calls (which CC API
+   *     doesn't expose uniformly). Cost vs. value isn't worth it; users
+   *     who need adoption for CC-API-only resource types should pass
+   *     `--resource <id>=<physicalId>` for those resources.
+   *
+   * SDK providers (S3, Lambda, IAM Role, etc.) implement their own
+   * `import` with tag-based auto-lookup; this fallback only kicks in for
+   * resource types that don't have a dedicated SDK provider.
+   */
+  async import(input) {
+    if (!input.knownPhysicalId) {
+      return null;
+    }
+    try {
+      const resp = await this.cloudControlClient.send(
+        new GetResourceCommand2({
+          TypeName: input.resourceType,
+          Identifier: input.knownPhysicalId
+        })
+      );
+      let attributes = {};
+      const raw = resp.ResourceDescription?.Properties;
+      if (typeof raw === "string" && raw.length > 0) {
+        try {
+          const parsed = JSON.parse(raw);
+          if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            attributes = parsed;
+          }
+        } catch (parseErr) {
+          this.logger.debug(
+            `Failed to parse CC API ResourceModel for ${input.resourceType}/${input.knownPhysicalId}: ${parseErr instanceof Error ? parseErr.message : String(parseErr)}`
+          );
+        }
+      }
+      return { physicalId: input.knownPhysicalId, attributes };
+    } catch (error) {
+      const err = error;
+      if (err.name === "ResourceNotFoundException") {
+        return null;
+      }
+      throw error;
+    }
+  }
 };
 
 // src/provisioning/providers/custom-resource-provider.ts
@@ -30222,7 +30307,7 @@ import {
 } from "@aws-sdk/client-s3";
 init_aws_clients();
 
-// src/cli/commands/state-migrate-bucket.ts
+// src/cli/commands/state-migrate.ts
 import * as readline2 from "node:readline/promises";
 import { Command as Command9 } from "commander";
 import {
@@ -30240,7 +30325,7 @@ import {
 } from "@aws-sdk/client-s3";
 import { GetCallerIdentityCommand as GetCallerIdentityCommand8 } from "@aws-sdk/client-sts";
 init_aws_clients();
-async function stateMigrateBucketCommand(options) {
+async function stateMigrateCommand(options) {
   const logger = getLogger();
   if (options.verbose)
     logger.setLevel("debug");
@@ -30506,8 +30591,8 @@ async function confirmPrompt(prompt) {
     rl.close();
   }
 }
-function createStateMigrateBucketCommand() {
-  const cmd = new Command9("migrate-bucket").description(
+function createStateMigrateCommand() {
+  const cmd = new Command9("migrate").description(
     "Migrate state from the legacy region-suffixed bucket (cdkd-state-{account}-{region}) to the new region-free default (cdkd-state-{account}). Source bucket is kept by default; pass --remove-legacy to delete it after a successful migration."
   ).option(
     "--region <region>",
@@ -30522,7 +30607,7 @@ function createStateMigrateBucketCommand() {
     "--remove-legacy",
     "Delete the source bucket after successful migration. Default: keep it.",
     false
-  ).action(withErrorHandling(stateMigrateBucketCommand));
+  ).action(withErrorHandling(stateMigrateCommand));
   commonOptions.forEach((o) => cmd.addOption(o));
   return cmd;
 }
@@ -31096,7 +31181,7 @@ function formatBucketSource(source) {
     case "default":
       return "default (account ID from STS)";
     case "default-legacy":
-      return "default (legacy region-suffixed name; cdkd state migrate-bucket recommended)";
+      return "default (legacy region-suffixed name; cdkd state migrate recommended)";
   }
 }
 async function detectBucketRegion(awsClients, bucket) {
@@ -31211,7 +31296,7 @@ function createStateCommand() {
   cmd.addCommand(createStateShowCommand());
   cmd.addCommand(createStateRmCommand());
   cmd.addCommand(createStateDestroyCommand());
-  cmd.addCommand(createStateMigrateBucketCommand());
+  cmd.addCommand(createStateMigrateCommand());
   return cmd;
 }
 
@@ -31576,7 +31661,7 @@ function reorderArgs(argv) {
 }
 async function main() {
   const program = new Command12();
-  program.name("cdkd").description("CDK Direct - Deploy AWS CDK apps directly via SDK/Cloud Control API").version("0.15.0");
+  program.name("cdkd").description("CDK Direct - Deploy AWS CDK apps directly via SDK/Cloud Control API").version("0.16.1");
   program.addCommand(createBootstrapCommand());
   program.addCommand(createSynthCommand());
   program.addCommand(createListCommand());