@go-to-k/cdkd 0.5.0 → 0.6.0

package/dist/index.js

@@ -3024,6 +3024,18 @@ var LockManager = class {
       );
     }
   }
+  /**
+   * Check whether a lock currently exists for a stack
+   *
+   * Returns true if a lock file is present in S3 (regardless of expiry).
+   * This is intended for read-only inspection (e.g. `cdkd state list --long`),
+   * not for acquisition decisions — use `acquireLock` for that, which has its
+   * own expired-lock cleanup logic.
+   */
+  async isLocked(stackName) {
+    const lockInfo = await this.getLockInfo(stackName);
+    return lockInfo !== null;
+  }
   /**
    * Release a lock for a stack
    */
@@ -7388,7 +7400,12 @@ var RETRYABLE_ERROR_MESSAGE_PATTERNS = [
   // 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"
+  "Could not deliver test message",
+  // SQS: same-name queue can't be re-created until 60s after a delete.
+  // Hits when a stack is destroyed and re-deployed in quick succession
+  // (a common dev / iteration loop). Retry recovers within ~60s instead
+  // of failing the whole deploy.
+  "wait 60 seconds"
 ];
 var RETRYABLE_HTTP_STATUS_CODES = /* @__PURE__ */ new Set([429, 503]);
 function isRetryableTransientError(error, message) {
@@ -7403,6 +7420,39 @@ function isRetryableTransientError(error, message) {
   return RETRYABLE_ERROR_MESSAGE_PATTERNS.some((p) => message.includes(p));
 }
 
+// src/deployment/retry.ts
+var defaultSleep = (ms) => new Promise((resolve4) => setTimeout(resolve4, ms));
+async function withRetry(operation, logicalId, opts = {}) {
+  const maxRetries = opts.maxRetries ?? 8;
+  const initialDelayMs = opts.initialDelayMs ?? 1e3;
+  const maxDelayMs = opts.maxDelayMs ?? 8e3;
+  const sleep = opts.sleep ?? defaultSleep;
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await operation();
+    } catch (error) {
+      lastError = error;
+      const message = error instanceof Error ? error.message : String(error);
+      const retryable = isRetryableTransientError(error, message);
+      if (!retryable || attempt >= maxRetries) {
+        throw error;
+      }
+      const delay = Math.min(initialDelayMs * Math.pow(2, attempt), maxDelayMs);
+      opts.logger?.debug(
+        `  \u23F3 Retrying ${logicalId} in ${delay / 1e3}s (attempt ${attempt + 1}/${maxRetries}) - ${message}`
+      );
+      for (let waited = 0; waited < delay; waited += 1e3) {
+        if (opts.isInterrupted?.()) {
+          throw opts.onInterrupted ? opts.onInterrupted() : new Error("Interrupted");
+        }
+        await sleep(Math.min(1e3, delay - waited));
+      }
+    }
+  }
+  throw lastError;
+}
+
 // src/deployment/deploy-engine.ts
 var InterruptedError = class extends Error {
   constructor() {
@@ -8389,32 +8439,20 @@ var DeployEngine = class {
     );
   }
   /**
-   * Execute an operation with retry for transient IAM propagation errors
-   */
-  async withRetry(operation, logicalId, maxRetries = 8, initialDelayMs = 1e4) {
-    let lastError;
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-      try {
-        return await operation();
-      } catch (error) {
-        lastError = error;
-        const message = error instanceof Error ? error.message : String(error);
-        const isRetryable = isRetryableTransientError(error, message);
-        if (!isRetryable || attempt >= maxRetries) {
-          throw error;
-        }
-        const delay = initialDelayMs * Math.pow(2, attempt);
-        this.logger.debug(
-          `  \u23F3 Retrying ${logicalId} in ${delay / 1e3}s (attempt ${attempt + 1}/${maxRetries}) - ${message}`
-        );
-        for (let waited = 0; waited < delay; waited += 1e3) {
-          if (this.interrupted)
-            throw new InterruptedError();
-          await new Promise((resolve4) => setTimeout(resolve4, Math.min(1e3, delay - waited)));
-        }
-      }
-    }
-    throw lastError;
+   * Execute an operation with retry for transient IAM propagation errors.
+   *
+   * Thin wrapper over `withRetry` from ./retry.js that injects this engine's
+   * SIGINT-aware interrupt check and logger. The actual backoff schedule
+   * lives there.
+   */
+  async withRetry(operation, logicalId, maxRetries, initialDelayMs) {
+    return withRetry(operation, logicalId, {
+      ...maxRetries !== void 0 && { maxRetries },
+      ...initialDelayMs !== void 0 && { initialDelayMs },
+      logger: this.logger,
+      isInterrupted: () => this.interrupted,
+      onInterrupted: () => new InterruptedError()
+    });
   }
   /**
    * Resolve stack outputs from template and resource attributes