@go-to-k/cdkd 0.35.0 → 0.36.0

package/README.md

@@ -376,6 +376,30 @@ cdkd state destroy MyStack --region us-east-1
 > `cdkd destroy` (synth-driven, deletes AWS resources + state) and
 > `cdkd state destroy` (state-driven, same effect) round out the matrix.
 
+## `publish-assets`: synth + build + publish, no deploy
+
+`cdkd publish-assets` runs the asset half of the deploy pipeline only —
+synthesize the CDK app, build any Docker images, upload file assets to
+S3, push images to ECR — and stops. No state writes, no provisioning,
+no lock acquisition. This is the typical CI split where one runner
+builds and uploads assets and a separate runner deploys.
+
+```bash
+cdkd publish-assets                          # synth + publish all stacks (or auto-detect single stack)
+cdkd publish-assets MyStack                  # synth + publish a specific stack
+cdkd publish-assets --all                    # synth + publish every stack in the app
+cdkd publish-assets 'MyStage/*'              # wildcard (CDK display path)
+cdkd publish-assets -a cdk.out               # skip synth — use a pre-synthesized cloud assembly
+```
+
+Stack selection follows the same rules as `deploy` / `diff` / `destroy`
+(positional > `--stack` > `--all` > auto-detect). Concurrency knobs
+are `--asset-publish-concurrency` and `--image-build-concurrency`.
+`-a/--app` accepts either a shell command (`"npx ts-node app.ts"`) or
+a path to an already-synthesized cloud assembly directory; pointing at
+`cdk.out` skips synthesis. See [docs/cli-reference.md](docs/cli-reference.md#publish-assets-synth--build--publish-no-deploy)
+for details.
+
 ## `--no-wait`: skip async-resource waits
 
 CloudFront Distributions, RDS Clusters/Instances, ElastiCache, and

package/dist/cli.js

@@ -34967,26 +34967,158 @@ function createOrphanCommand() {
 
 // src/cli/commands/publish-assets.ts
 import { Option as Option4, Command as Command9 } from "commander";
-async function publishAssetsCommand(options) {
+async function publishAssetsCommand(stacks, options) {
   const logger = getLogger();
   if (options.verbose) {
     logger.setLevel("debug");
   }
   warnIfDeprecatedRegion(options);
   await applyRoleArnIfSet({ roleArn: options.roleArn, region: options.region });
-  logger.info("Publishing assets...");
-  logger.debug("Asset manifest path:", options.path);
-  const publisher = new AssetPublisher();
-  await publisher.publishFromManifest(options.path, {
-    ...options.profile && { profile: options.profile },
+  const app = resolveApp(options.app);
+  if (!app) {
+    throw new Error(
+      'No app command specified. Use --app, set CDKD_APP env var, or add "app" to cdk.json'
+    );
+  }
+  logger.info("Synthesizing CDK app...");
+  const synthesizer = new Synthesizer();
+  const context = parseContextOptions(options.context);
+  const synthOptions = {
+    app,
+    output: options.output,
     ...options.region && { region: options.region },
-    assetPublishConcurrency: options.assetPublishConcurrency,
-    imageBuildConcurrency: options.imageBuildConcurrency
-  });
-  logger.info("\u2705 Asset publishing complete");
+    ...options.profile && { profile: options.profile },
+    ...Object.keys(context).length > 0 && { context }
+  };
+  const result = await synthesizer.synthesize(synthOptions);
+  const { stacks: allStacks } = result;
+  logger.debug(`Found ${allStacks.length} stack(s) in assembly`);
+  const stackPatterns = stacks.length > 0 ? stacks : options.stack ? [options.stack] : [];
+  let targetStacks;
+  if (options.all) {
+    targetStacks = allStacks;
+  } else if (stackPatterns.length > 0) {
+    targetStacks = matchStacks(allStacks, stackPatterns);
+  } else if (allStacks.length === 1) {
+    targetStacks = allStacks;
+  } else {
+    throw new Error(
+      `Multiple stacks found: ${allStacks.map(describeStack).join(", ")}. Specify stack name(s) or use --all`
+    );
+  }
+  if (targetStacks.length === 0) {
+    throw new Error(
+      stackPatterns.length > 0 ? `No stacks matching ${stackPatterns.join(", ")} found in assembly. Available: ${allStacks.map(describeStack).join(", ")}` : "No stacks found in assembly"
+    );
+  }
+  const baseRegion = options.region || process.env["AWS_REGION"] || "us-east-1";
+  const { STSClient: STSClient10, GetCallerIdentityCommand: GetCallerIdentityCommand11 } = await import("@aws-sdk/client-sts");
+  const stsClient = new STSClient10({ region: baseRegion });
+  const callerIdentity = await stsClient.send(new GetCallerIdentityCommand11({}));
+  const accountId = callerIdentity.Account;
+  stsClient.destroy();
+  const assetPublisher = new AssetPublisher();
+  const results = [];
+  for (const stack of targetStacks) {
+    const startedAt = Date.now();
+    let assetCount = 0;
+    let error;
+    try {
+      if (!stack.assetManifestPath) {
+        logger.debug(`Stack ${stack.stackName} has no asset manifest; nothing to publish`);
+        results.push({
+          stackName: stack.stackName,
+          displayName: stack.displayName,
+          assetCount: 0,
+          durationMs: Date.now() - startedAt
+        });
+        continue;
+      }
+      logger.info(`
+Publishing assets for stack: ${describeStack(stack)}`);
+      const workGraph = new WorkGraph();
+      let nodeIds = [];
+      try {
+        nodeIds = assetPublisher.addAssetsToGraph(workGraph, stack.assetManifestPath, {
+          accountId,
+          region: stack.region || baseRegion,
+          ...options.profile && { profile: options.profile },
+          nodePrefix: `${stack.stackName}:`
+        });
+      } catch (err) {
+        const e = err;
+        if (e.code === "ENOENT") {
+          logger.debug(
+            `Asset manifest not found for ${stack.stackName} (${stack.assetManifestPath}); skipping`
+          );
+          results.push({
+            stackName: stack.stackName,
+            displayName: stack.displayName,
+            assetCount: 0,
+            durationMs: Date.now() - startedAt
+          });
+          continue;
+        }
+        throw err;
+      }
+      assetCount = nodeIds.filter((id) => id.startsWith("asset-publish:")).length;
+      if (assetCount === 0) {
+        logger.info("  (no assets to publish)");
+        results.push({
+          stackName: stack.stackName,
+          displayName: stack.displayName,
+          assetCount: 0,
+          durationMs: Date.now() - startedAt
+        });
+        continue;
+      }
+      await workGraph.execute(
+        {
+          "asset-build": options.imageBuildConcurrency,
+          "asset-publish": options.assetPublishConcurrency,
+          stack: 0
+        },
+        (node) => assetPublisher.executeNode(node)
+      );
+      logger.info(
+        `  \u2713 Published ${assetCount} asset(s) in ${((Date.now() - startedAt) / 1e3).toFixed(2)}s`
+      );
+    } catch (err) {
+      error = err instanceof Error ? err : new Error(String(err));
+      logger.error(`  \u2717 ${stack.stackName}: ${error.message}`);
+    }
+    results.push({
+      stackName: stack.stackName,
+      displayName: stack.displayName,
+      assetCount,
+      durationMs: Date.now() - startedAt,
+      ...error && { error }
+    });
+  }
+  const failed = results.filter((r) => r.error);
+  const totalAssets = results.reduce((sum, r) => sum + r.assetCount, 0);
+  logger.info("\nPublish Summary:");
+  for (const r of results) {
+    const tag = r.error ? "\u2717" : "\u2713";
+    const id = r.displayName === r.stackName ? r.stackName : `${r.displayName} (${r.stackName})`;
+    const detail = r.error ? `failed: ${r.error.message}` : `${r.assetCount} asset(s), ${(r.durationMs / 1e3).toFixed(2)}s`;
+    logger.info(`  ${tag} ${id} \u2014 ${detail}`);
+  }
+  if (failed.length > 0) {
+    throw new PartialFailureError(
+      `Asset publishing completed with ${failed.length} stack failure(s) (${totalAssets} asset(s) published successfully across the rest).`
+    );
+  }
+  logger.info(`
+\u2705 Asset publishing complete (${totalAssets} asset(s))`);
 }
 function createPublishAssetsCommand() {
-  const cmd = new Command9("publish-assets").description("Publish assets to S3/ECR from asset manifest").requiredOption("--path <path>", "Path to asset manifest file or directory").addOption(
+  const cmd = new Command9("publish-assets").description(
+    "Synthesize the CDK app and publish assets to S3/ECR for the selected stack(s) without deploying"
+  ).argument(
+    "[stacks...]",
+    "Stack name(s) to publish assets for. Accepts physical CloudFormation names (e.g. 'MyStage-Api') or CDK display paths (e.g. 'MyStage/Api'). Supports wildcards."
+  ).option("--all", "Publish assets for all stacks", false).addOption(
     new Option4(
       "--asset-publish-concurrency <number>",
       "Maximum concurrent asset publish operations"
@@ -34994,7 +35126,8 @@ function createPublishAssetsCommand() {
   ).addOption(
     new Option4("--image-build-concurrency <number>", "Maximum concurrent Docker image builds").default(4).argParser((value) => parseInt(value, 10))
   ).action(withErrorHandling(publishAssetsCommand));
-  commonOptions.forEach((opt) => cmd.addOption(opt));
+  [...commonOptions, ...appOptions, ...contextOptions].forEach((opt) => cmd.addOption(opt));
+  cmd.addOption(new Option4("--stack <name>", "Stack name to publish (alternative to positional)"));
   cmd.addOption(deprecatedRegionOption);
   return cmd;
 }
@@ -36849,7 +36982,7 @@ function reorderArgs(argv) {
 }
 async function main() {
   const program = new Command14();
-  program.name("cdkd").description("CDK Direct - Deploy AWS CDK apps directly via SDK/Cloud Control API").version("0.35.0");
+  program.name("cdkd").description("CDK Direct - Deploy AWS CDK apps directly via SDK/Cloud Control API").version("0.36.0");
   program.addCommand(createBootstrapCommand());
   program.addCommand(createSynthCommand());
   program.addCommand(createListCommand());