@go-to-k/cdkd 0.3.6 → 0.4.1

package/dist/index.js

@@ -432,6 +432,141 @@ var init_aws_clients = __esm({
   }
 });
 
+// src/utils/live-renderer.ts
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var FRAME_INTERVAL_MS = 80;
+var ESC = "\x1B[";
+var LiveRenderer = class {
+  constructor(stream = process.stdout) {
+    this.stream = stream;
+  }
+  tasks = /* @__PURE__ */ new Map();
+  active = false;
+  spinnerIndex = 0;
+  interval = null;
+  linesDrawn = 0;
+  cursorHidden = false;
+  exitListener = null;
+  isActive() {
+    return this.active;
+  }
+  /**
+   * Enable the live renderer. No-op if stdout is not a TTY or if
+   * `CDKD_NO_LIVE=1`. Returns true if successfully enabled.
+   */
+  start() {
+    if (this.active)
+      return true;
+    if (!this.stream.isTTY)
+      return false;
+    if (process.env["CDKD_NO_LIVE"] === "1")
+      return false;
+    this.active = true;
+    this.hideCursor();
+    if (!this.exitListener) {
+      this.exitListener = () => this.showCursor();
+      process.on("exit", this.exitListener);
+    }
+    this.interval = setInterval(() => this.draw(), FRAME_INTERVAL_MS);
+    if (typeof this.interval.unref === "function")
+      this.interval.unref();
+    return true;
+  }
+  stop() {
+    if (!this.active)
+      return;
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+    this.clear();
+    this.showCursor();
+    if (this.exitListener) {
+      process.removeListener("exit", this.exitListener);
+      this.exitListener = null;
+    }
+    this.tasks.clear();
+    this.active = false;
+  }
+  addTask(id, label) {
+    this.tasks.set(id, { label, startedAt: Date.now() });
+    if (this.active)
+      this.draw();
+  }
+  removeTask(id) {
+    if (!this.tasks.delete(id))
+      return;
+    if (this.active)
+      this.draw();
+  }
+  /**
+   * Print content above the live area. Clears the live area, runs the writer,
+   * then redraws the live area. When the renderer is inactive, the writer
+   * runs directly so callers can use this unconditionally.
+   */
+  printAbove(write) {
+    if (!this.active) {
+      write();
+      return;
+    }
+    this.clear();
+    write();
+    this.draw();
+  }
+  clear() {
+    if (this.linesDrawn === 0)
+      return;
+    this.stream.write("\r");
+    for (let i = 0; i < this.linesDrawn; i++) {
+      this.stream.write(`${ESC}1A${ESC}2K`);
+    }
+    this.linesDrawn = 0;
+  }
+  draw() {
+    if (!this.active)
+      return;
+    this.clear();
+    if (this.tasks.size === 0)
+      return;
+    const frame = SPINNER_FRAMES[this.spinnerIndex % SPINNER_FRAMES.length];
+    this.spinnerIndex++;
+    const cols = this.stream.columns ?? 80;
+    const lines = [];
+    for (const task of this.tasks.values()) {
+      const elapsed = ((Date.now() - task.startedAt) / 1e3).toFixed(1);
+      const raw = `  ${frame} ${task.label} (${elapsed}s)`;
+      lines.push(this.truncate(raw, cols));
+    }
+    this.stream.write(lines.join("\n") + "\n");
+    this.linesDrawn = lines.length;
+  }
+  truncate(s, maxLen) {
+    if (s.length <= maxLen)
+      return s;
+    if (maxLen <= 1)
+      return "\u2026";
+    return s.substring(0, maxLen - 1) + "\u2026";
+  }
+  hideCursor() {
+    if (this.cursorHidden)
+      return;
+    this.stream.write(`${ESC}?25l`);
+    this.cursorHidden = true;
+  }
+  showCursor() {
+    if (!this.cursorHidden)
+      return;
+    this.stream.write(`${ESC}?25h`);
+    this.cursorHidden = false;
+  }
+};
+var globalRenderer = null;
+function getLiveRenderer() {
+  if (!globalRenderer)
+    globalRenderer = new LiveRenderer();
+  return globalRenderer;
+}
+
 // src/utils/logger.ts
 var colors = {
   reset: "\x1B[0m",
@@ -488,22 +623,26 @@ var ConsoleLogger = class {
   }
   debug(message, ...args) {
     if (this.shouldLog("debug")) {
-      console.debug(this.formatMessage("debug", message, ...args));
+      const formatted = this.formatMessage("debug", message, ...args);
+      getLiveRenderer().printAbove(() => console.debug(formatted));
     }
   }
   info(message, ...args) {
     if (this.shouldLog("info")) {
-      console.info(this.formatMessage("info", message, ...args));
+      const formatted = this.formatMessage("info", message, ...args);
+      getLiveRenderer().printAbove(() => console.info(formatted));
     }
   }
   warn(message, ...args) {
     if (this.shouldLog("warn")) {
-      console.warn(this.formatMessage("warn", message, ...args));
+      const formatted = this.formatMessage("warn", message, ...args);
+      getLiveRenderer().printAbove(() => console.warn(formatted));
     }
   }
   error(message, ...args) {
     if (this.shouldLog("error")) {
-      console.error(this.formatMessage("error", message, ...args));
+      const formatted = this.formatMessage("error", message, ...args);
+      getLiveRenderer().printAbove(() => console.error(formatted));
     }
   }
   /**
@@ -934,6 +1073,7 @@ var AssemblyReader = class {
     }
     return {
       stackName,
+      displayName: artifact.displayName ?? stackName,
       artifactId,
       template,
       assetManifestPath,
@@ -7212,6 +7352,57 @@ var IMPLICIT_DELETE_DEPENDENCIES = {
   ]
 };
 
+// src/deployment/retryable-errors.ts
+var RETRYABLE_ERROR_MESSAGE_PATTERNS = [
+  // IAM propagation
+  "cannot be assumed",
+  "role defined for the function",
+  "not authorized to perform",
+  "execution role",
+  "trust policy",
+  "Role validation failed",
+  "does not have required permissions",
+  "Trusted Entity",
+  "currently in the following state: Pending",
+  // DELETE dependency ordering (parallel deletion race conditions)
+  "has dependencies and cannot be deleted",
+  "can't be deleted since it has",
+  "DependencyViolation",
+  // AWS eventual consistency (dependency just created but not yet visible)
+  // e.g., RDS DBCluster referencing a just-created DBSubnetGroup
+  "does not exist",
+  // AppSync schema is being created asynchronously
+  "Schema is currently being altered",
+  // IAM principal not yet propagated to S3 bucket policy
+  "Invalid principal in policy",
+  // S3 bucket creation/deletion still in progress
+  "conflicting conditional operation",
+  // Secrets Manager: ForceDeleteWithoutRecovery may take a moment to propagate
+  "scheduled for deletion",
+  // DynamoDB Streams / Kinesis: IAM role not yet propagated
+  "Cannot access stream",
+  "Please ensure the role can perform",
+  // KMS: IAM role not yet propagated for CreateGrant
+  "KMS key is invalid for CreateGrant",
+  // CloudWatch Logs SubscriptionFilter: Kinesis stream eventual consistency
+  // or SubscriptionFilter role propagation. CW Logs probes the destination
+  // by delivering a test message; if the stream is freshly ACTIVE or the
+  // assumed role hasn't propagated, the probe fails with "Invalid request".
+  "Could not deliver test message"
+];
+var RETRYABLE_HTTP_STATUS_CODES = /* @__PURE__ */ new Set([429, 503]);
+function isRetryableTransientError(error, message) {
+  const metadata = error.$metadata;
+  const statusCode = metadata?.httpStatusCode;
+  if (statusCode !== void 0 && RETRYABLE_HTTP_STATUS_CODES.has(statusCode))
+    return true;
+  const cause = error.cause;
+  const causeStatus = cause?.$metadata?.httpStatusCode;
+  if (causeStatus !== void 0 && RETRYABLE_HTTP_STATUS_CODES.has(causeStatus))
+    return true;
+  return RETRYABLE_ERROR_MESSAGE_PATTERNS.some((p) => message.includes(p));
+}
+
 // src/deployment/deploy-engine.ts
 var InterruptedError = class extends Error {
   constructor() {
@@ -7247,11 +7438,15 @@ var DeployEngine = class {
     this.logger.debug(`Starting deployment for stack: ${stackName}`);
     setCurrentStackName(stackName);
     await this.lockManager.acquireLockWithRetry(stackName, void 0, "deploy");
+    const renderer = getLiveRenderer();
+    renderer.start();
     this.interrupted = false;
     const sigintHandler = () => {
-      process.stderr.write(
-        "\nInterrupted \u2014 saving partial state after current operations complete...\n"
-      );
+      renderer.printAbove(() => {
+        process.stderr.write(
+          "\nInterrupted \u2014 saving partial state after current operations complete...\n"
+        );
+      });
       this.interrupted = true;
     };
     process.on("SIGINT", sigintHandler);
@@ -7366,6 +7561,7 @@ var DeployEngine = class {
         durationMs
       };
     } finally {
+      renderer.stop();
       process.removeListener("SIGINT", sigintHandler);
       try {
         await this.lockManager.releaseLock(stackName);
@@ -7794,6 +7990,10 @@ var DeployEngine = class {
   async provisionResource(logicalId, change, stateResources, stackName, template, parameterValues, conditions, counts, progress) {
     const resourceType = change.resourceType;
     const provider = this.providerRegistry.getProvider(resourceType);
+    const renderer = getLiveRenderer();
+    const needsReplacement = change.changeType === "UPDATE" && (change.propertyChanges?.some((pc) => pc.requiresReplacement) ?? false);
+    const verb = change.changeType === "CREATE" ? "Creating" : change.changeType === "DELETE" ? "Deleting" : needsReplacement ? "Replacing" : "Updating";
+    renderer.addTask(logicalId, `${verb} ${logicalId} (${resourceType})`);
     try {
       switch (change.changeType) {
         case "CREATE": {
@@ -7825,6 +8025,7 @@ var DeployEngine = class {
           if (progress)
             progress.current++;
           const createPrefix = progress ? `[${progress.current}/${progress.total}] ` : "  ";
+          renderer.removeTask(logicalId);
           this.logger.info(`${createPrefix}\u2705 ${logicalId} (${resourceType}) created`);
           break;
         }
@@ -7852,9 +8053,9 @@ var DeployEngine = class {
               counts.skipped++;
             break;
           }
-          const needsReplacement = change.propertyChanges?.some((pc) => pc.requiresReplacement);
+          const needsReplacement2 = change.propertyChanges?.some((pc) => pc.requiresReplacement);
           const dependencies = this.extractAllDependencies(template, logicalId);
-          if (needsReplacement) {
+          if (needsReplacement2) {
             const replacedProps = change.propertyChanges?.filter((pc) => pc.requiresReplacement).map((pc) => pc.path).join(", ");
             this.logger.info(
               `Replacing ${logicalId} (${resourceType}) - immutable properties changed: ${replacedProps}`
@@ -7898,6 +8099,7 @@ var DeployEngine = class {
             if (progress)
               progress.current++;
             const replacePrefix = progress ? `[${progress.current}/${progress.total}] ` : "  ";
+            renderer.removeTask(logicalId);
             this.logger.info(`${replacePrefix}\u2705 ${logicalId} (${resourceType}) replaced`);
           } else {
             this.logger.debug(`Updating ${logicalId} (${resourceType})`);
@@ -7973,6 +8175,7 @@ var DeployEngine = class {
             if (progress)
               progress.current++;
             const updatePrefix = progress ? `[${progress.current}/${progress.total}] ` : "  ";
+            renderer.removeTask(logicalId);
             this.logger.info(`${updatePrefix}\u2705 ${logicalId} (${resourceType}) updated`);
           }
           break;
@@ -8018,11 +8221,13 @@ var DeployEngine = class {
           if (progress)
             progress.current++;
           const deletePrefix = progress ? `[${progress.current}/${progress.total}] ` : "  ";
+          renderer.removeTask(logicalId);
           this.logger.info(`${deletePrefix}\u2705 ${logicalId} (${resourceType}) deleted`);
           break;
         }
       }
     } catch (error) {
+      renderer.removeTask(logicalId);
       const message = error instanceof Error ? error.message : String(error);
       this.logger.error(`Failed to ${change.changeType.toLowerCase()} ${logicalId}: ${message}`);
       throw new ProvisioningError(
@@ -8032,6 +8237,8 @@ var DeployEngine = class {
         stateResources[logicalId]?.physicalId,
         error instanceof Error ? error : void 0
       );
+    } finally {
+      renderer.removeTask(logicalId);
     }
   }
   /**
@@ -8192,7 +8399,7 @@ var DeployEngine = class {
       } catch (error) {
         lastError = error;
         const message = error instanceof Error ? error.message : String(error);
-        const isRetryable = this.isRetryableError(error, message);
+        const isRetryable = isRetryableTransientError(error, message);
         if (!isRetryable || attempt >= maxRetries) {
           throw error;
         }
@@ -8209,53 +8416,6 @@ var DeployEngine = class {
     }
     throw lastError;
   }
-  /**
-   * Determine if an error is retryable (transient).
-   * Checks HTTP status codes (429 throttle, 503 unavailable)
-   * and IAM propagation delay message patterns.
-   */
-  isRetryableError(error, message) {
-    const metadata = error.$metadata;
-    const statusCode = metadata?.httpStatusCode;
-    if (statusCode === 429 || statusCode === 503)
-      return true;
-    const cause = error.cause;
-    const causeStatus = cause?.$metadata?.httpStatusCode;
-    if (causeStatus === 429 || causeStatus === 503)
-      return true;
-    const retryablePatterns = [
-      "cannot be assumed",
-      "role defined for the function",
-      "not authorized to perform",
-      "execution role",
-      "trust policy",
-      "Role validation failed",
-      "does not have required permissions",
-      "Trusted Entity",
-      "currently in the following state: Pending",
-      // DELETE dependency ordering (parallel deletion race conditions)
-      "has dependencies and cannot be deleted",
-      "can't be deleted since it has",
-      "DependencyViolation",
-      // AWS eventual consistency (dependency just created but not yet visible)
-      // e.g., RDS DBCluster referencing a just-created DBSubnetGroup
-      "does not exist",
-      // AppSync schema is being created asynchronously
-      "Schema is currently being altered",
-      // IAM principal not yet propagated to S3 bucket policy
-      "Invalid principal in policy",
-      // S3 bucket creation/deletion still in progress
-      "conflicting conditional operation",
-      // Secrets Manager: ForceDeleteWithoutRecovery may take a moment to propagate
-      "scheduled for deletion",
-      // DynamoDB Streams / Kinesis: IAM role not yet propagated
-      "Cannot access stream",
-      "Please ensure the role can perform",
-      // KMS: IAM role not yet propagated for CreateGrant
-      "KMS key is invalid for CreateGrant"
-    ];
-    return retryablePatterns.some((p) => message.includes(p));
-  }
   /**
    * Resolve stack outputs from template and resource attributes
    *