stacktape 3.5.7 → 3.6.0-beta.0

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,68 +216,208 @@ 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;
     }
 
-    printLogo();
+    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
+    }
+  };
 
-    return binaryPath;
-  } catch (error) {
-    console.error(`
-${colors.red}Error installing Stacktape:${colors.reset}
-${error.message}
+  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
+        }
 
-You can also install Stacktape directly using:
-${getManualInstallCommand(platformKey)}`);
-    process.exit(1);
-  }
-}
+        if (Date.now() - start > LOCK_WAIT_TIMEOUT_MS) {
+          throw new Error('Timed out waiting for Stacktape binary installation lock');
+        }
 
-function getManualInstallCommand(platformKey) {
-  const commands = {
-    'win32-x64': 'iwr https://installs.stacktape.com/windows.ps1 -useb | iex',
-    'linux-x64': 'curl -L https://installs.stacktape.com/linux.sh | sh',
-    'linux-arm64': 'curl -L https://installs.stacktape.com/linux-arm.sh | sh',
-    'linux-x64-musl': 'curl -L https://installs.stacktape.com/alpine.sh | sh',
-    'darwin-x64': 'curl -L https://installs.stacktape.com/macos.sh | sh',
-    'darwin-arm64': 'curl -L https://installs.stacktape.com/macos-arm.sh | sh'
+        await sleep(200);
+      }
+    }
   };
-  return commands[platformKey] || 'See https://docs.stacktape.com for installation instructions';
+
+  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);
+
+      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;
+  }
+
+  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();
+  }
 }
 
 function getGlobalBinaryPathIfVersionMatches() {
@@ -269,6 +425,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 +436,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.7",
+  "version": "3.6.0-beta.0",
   "description": "PaaS 2.0 that deploys to your own AWS account.",
   "author": "Stacktape team <support@stacktape.com>",
   "license": "MIT",