stacktape 3.5.6 → 3.5.8

package/bin/stacktape.js

@@ -14,7 +14,11 @@ const {
   accessSync,
   constants,
   unlinkSync,
-  readFileSync
+  readFileSync,
+  writeFileSync,
+  readdirSync,
+  rmSync,
+  statSync
 } = require('node:fs');
 const { get: httpsGet } = require('node:https');
 const { platform, arch, homedir } = require('node:os');
@@ -33,6 +37,18 @@ const PLATFORM_MAP = {
   'linux-x64-musl': { fileName: 'alpine.tar.gz', extract: extractTarGz }
 };
 
+const REQUIRED_HELPER_LAMBDA_PREFIXES = [
+  'stacktapeServiceLambda',
+  'cdnOriginRequestLambda',
+  'cdnOriginResponseLambda',
+  'batchJobTriggerLambda'
+];
+
+const INSTALL_MARKER_FILE_NAME = '.stacktape-install.json';
+const INSTALL_LOCK_DIR_SUFFIX = '.stacktape-install.lock';
+const LOCK_WAIT_TIMEOUT_MS = 120000;
+const STALE_LOCK_TIMEOUT_MS = 300000;
+
 // ANSI color codes
 const colors = {
   reset: '\x1B[0m',
@@ -200,55 +216,207 @@ async function ensureBinary() {
 
   const binaryName = platform() === 'win32' ? 'stacktape.exe' : 'stacktape';
 
+  const localCacheDir = join(__dirname, '..', 'bin');
+
   let cacheDir;
   try {
-    const localDir = join(__dirname, '..', 'bin');
-    mkdirSync(localDir, { recursive: true });
-    accessSync(localDir, constants.W_OK);
-    cacheDir = localDir;
+    mkdirSync(localCacheDir, { recursive: true });
+    accessSync(localCacheDir, constants.W_OK);
+    cacheDir = localCacheDir;
   } catch {
     cacheDir = join(homedir(), '.stacktape', 'bin', version);
   }
 
   const binaryPath = join(cacheDir, binaryName);
+  const preserveLauncherScript = cacheDir === localCacheDir;
 
-  if (existsSync(binaryPath)) {
-    return binaryPath;
-  }
+  const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
-  console.info(`${colors.dim}Installing Stacktape ${version} for ${platformKey}...${colors.reset}`);
+  const lockDirPath = `${cacheDir}${INSTALL_LOCK_DIR_SUFFIX}`;
 
-  mkdirSync(cacheDir, { recursive: true });
+  const isHelperLambdasCacheComplete = () => {
+    const helperLambdasDir = join(cacheDir, 'helper-lambdas');
+    if (!existsSync(helperLambdasDir)) {
+      return false;
+    }
 
-  const downloadUrl = `https://github.com/${GITHUB_REPO}/releases/download/${version}/${platformInfo.fileName}`;
-  const archivePath = join(cacheDir, platformInfo.fileName);
+    try {
+      const files = readdirSync(helperLambdasDir);
+      return REQUIRED_HELPER_LAMBDA_PREFIXES.every((prefix) =>
+        files.some((fileName) => fileName.startsWith(`${prefix}-`) && fileName.endsWith('.zip'))
+      );
+    } catch {
+      return false;
+    }
+  };
 
-  try {
-    console.info(`${colors.dim}Downloading from GitHub releases...${colors.reset}`);
-    await downloadFile(downloadUrl, archivePath);
+  const isCacheValid = () => {
+    if (!existsSync(binaryPath)) {
+      return false;
+    }
 
-    console.info(`${colors.dim}Extracting...${colors.reset}`);
-    await platformInfo.extract(archivePath, cacheDir);
+    if (!isHelperLambdasCacheComplete()) {
+      return false;
+    }
 
-    setExecutablePermissions(cacheDir);
+    const markerPath = join(cacheDir, INSTALL_MARKER_FILE_NAME);
+    if (!existsSync(markerPath)) {
+      return false;
+    }
 
-    unlinkSync(archivePath);
+    try {
+      const parsedMarker = JSON.parse(readFileSync(markerPath, 'utf8'));
+      return parsedMarker.version === version && parsedMarker.platformKey === platformKey;
+    } catch {
+      return false;
+    }
+  };
 
-    if (!existsSync(binaryPath)) {
-      throw new Error(`Binary not found after extraction: ${binaryPath}`);
+  const writeInstallMarker = () => {
+    const markerPath = join(cacheDir, INSTALL_MARKER_FILE_NAME);
+    writeFileSync(
+      markerPath,
+      JSON.stringify(
+        {
+          version,
+          platformKey,
+          helperLambdas: REQUIRED_HELPER_LAMBDA_PREFIXES,
+          installedAt: new Date().toISOString()
+        },
+        null,
+        2
+      )
+    );
+  };
+
+  const cleanupExtractedCache = () => {
+    if (!existsSync(cacheDir)) {
+      return;
+    }
+
+    try {
+      const entries = readdirSync(cacheDir);
+      for (const entry of entries) {
+        if (preserveLauncherScript && entry === 'stacktape.js') {
+          continue;
+        }
+        rmSync(join(cacheDir, entry), { recursive: true, force: true });
+      }
+    } catch {
+      // Ignore cleanup errors and try reinstall anyway
+    }
+  };
+
+  const acquireInstallLock = async () => {
+    const start = Date.now();
+    while (true) {
+      try {
+        mkdirSync(lockDirPath);
+        return;
+      } catch (error) {
+        if (error.code !== 'EEXIST') {
+          throw error;
+        }
+
+        try {
+          const lockStats = statSync(lockDirPath);
+          const lockAge = Date.now() - lockStats.mtimeMs;
+          if (lockAge > STALE_LOCK_TIMEOUT_MS) {
+            rmSync(lockDirPath, { recursive: true, force: true });
+            continue;
+          }
+        } catch {
+          // Lock directory disappeared between checks
+        }
+
+        if (Date.now() - start > LOCK_WAIT_TIMEOUT_MS) {
+          throw new Error('Timed out waiting for Stacktape binary installation lock');
+        }
+
+        await sleep(200);
+      }
+    }
+  };
+
+  const releaseInstallLock = () => {
+    try {
+      rmSync(lockDirPath, { recursive: true, force: true });
+    } catch {
+      // Ignore release lock errors
     }
+  };
+
+  const installBinary = async () => {
+    console.info(`${colors.dim}Installing Stacktape ${version} for ${platformKey}...${colors.reset}`);
+
+    mkdirSync(cacheDir, { recursive: true });
+
+    const downloadUrl = `https://github.com/${GITHUB_REPO}/releases/download/${version}/${platformInfo.fileName}`;
+    const archivePath = join(cacheDir, `.download-${Date.now()}-${platformInfo.fileName}`);
+
+    try {
+      console.info(`${colors.dim}Downloading from GitHub releases...${colors.reset}`);
+      await downloadFile(downloadUrl, archivePath);
+
+      console.info(`${colors.dim}Extracting...${colors.reset}`);
+      await platformInfo.extract(archivePath, cacheDir);
 
-    printLogo();
+      setExecutablePermissions(cacheDir);
 
+      unlinkSync(archivePath);
+
+      if (!existsSync(binaryPath)) {
+        throw new Error(`Binary not found after extraction: ${binaryPath}`);
+      }
+
+      if (!isHelperLambdasCacheComplete()) {
+        throw new Error('Incomplete installation: helper lambdas were not extracted correctly');
+      }
+
+      writeInstallMarker();
+      printLogo();
+
+      return binaryPath;
+    } catch (error) {
+      try {
+        if (existsSync(archivePath)) {
+          unlinkSync(archivePath);
+        }
+      } catch {
+        // Ignore archive cleanup errors
+      }
+      throw error;
+    }
+  };
+
+  if (isCacheValid()) {
     return binaryPath;
-  } catch (error) {
-    console.error(`
-${colors.red}Error installing Stacktape:${colors.reset}
-${error.message}
+  }
 
-You can also install Stacktape directly using:
-${getManualInstallCommand(platformKey)}`);
-    process.exit(1);
+  await acquireInstallLock();
+
+  try {
+    if (isCacheValid()) {
+      return binaryPath;
+    }
+
+    let lastError;
+    for (let attempt = 1; attempt <= 2; attempt++) {
+      try {
+        cleanupExtractedCache();
+        return await installBinary();
+      } catch (error) {
+        lastError = error;
+        cleanupExtractedCache();
+        if (attempt < 2) {
+          console.info(`\n${colors.dim}Retrying installation (${attempt + 1}/2)...${colors.reset}`);
+        }
+      }
+    }
+
+    throw lastError;
+  } finally {
+    releaseInstallLock();
   }
 }
 
@@ -269,6 +437,7 @@ function getGlobalBinaryPathIfVersionMatches() {
   const globalDir = join(homedir(), '.stacktape', 'bin');
   const globalBinaryPath = join(globalDir, binaryName);
   const releaseDataPath = join(globalDir, 'release-data.json');
+  const globalHelperLambdasDir = join(globalDir, 'helper-lambdas');
 
   if (!existsSync(globalBinaryPath) || !existsSync(releaseDataPath)) {
     return null;
@@ -279,6 +448,14 @@ function getGlobalBinaryPathIfVersionMatches() {
     if (version !== PACKAGE_VERSION) {
       return null;
     }
+
+    const files = readdirSync(globalHelperLambdasDir);
+    const hasAllHelperLambdas = REQUIRED_HELPER_LAMBDA_PREFIXES.every((prefix) =>
+      files.some((fileName) => fileName.startsWith(`${prefix}-`) && fileName.endsWith('.zip'))
+    );
+    if (!hasAllHelperLambdas) {
+      return null;
+    }
   } catch {
     return null;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stacktape",
-  "version": "3.5.6",
+  "version": "3.5.8",
   "description": "PaaS 2.0 that deploys to your own AWS account.",
   "author": "Stacktape team <support@stacktape.com>",
   "license": "MIT",

package/plain.d.ts

@@ -6275,14 +6275,16 @@ export interface ApplicationLoadBalancerProps {
    */
   interface?: "internal" | "internet";
   /**
-   * #### Custom domains. Stacktape auto-creates DNS records and TLS certificates.
+   * #### Custom domains.
    *
    * ---
    *
-   * Your domain must be added as a Route53 hosted zone in your AWS account first.
-   * Use `customCertificateArns` on listeners if you want to bring your own certificates.
+   * By default, Stacktape creates DNS records and TLS certificates for each domain.
+   * If you manage DNS yourself, set `disableDnsRecordCreation` and provide `customCertificateArn`.
+   *
+   * Backward compatible format `string[]` is still supported.
    */
-  customDomains?: string[];
+  customDomains?: string[] | DomainConfiguration[];
   /**
    * #### Custom listeners (port + protocol). Defaults to HTTPS on 443 + HTTP on 80 (redirecting to HTTPS).
    */
@@ -6594,13 +6596,16 @@ export interface NetworkLoadBalancerProps {
    */
   interface?: "internal" | "internet";
   /**
-   * #### Custom domains. Stacktape auto-creates DNS records and TLS certificates for TLS listeners.
+   * #### Custom domains.
    *
    * ---
    *
-   * Your domain must be added as a Route53 hosted zone in your AWS account first.
+   * By default, Stacktape creates DNS records and TLS certificates for each domain.
+   * If you manage DNS yourself, set `disableDnsRecordCreation` and provide `customCertificateArn`.
+   *
+   * Backward compatible format `string[]` is still supported.
    */
-  customDomains?: string[];
+  customDomains?: string[] | DomainConfiguration[];
   /**
    * #### Listeners define which ports and protocols (TCP/TLS) this load balancer accepts traffic on.
    */