tessl 0.92.0 → 0.94.0

package/bin/tessl.js

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
 
 // installer/src/main.ts
-import { existsSync as existsSync3, rmSync } from "node:fs";
+import { existsSync as existsSync3 } from "node:fs";
+import { mkdir as mkdir3, rm as rm2 } from "node:fs/promises";
+import { basename as basename2, join as join2 } from "node:path";
 import { createInterface } from "node:readline";
 import { Readable as Readable2 } from "node:stream";
 
@@ -148,6 +150,40 @@ import {
 } from "node:fs/promises";
 import { homedir } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
+
+// installer/src/validate.ts
+import { spawnSync } from "node:child_process";
+function validateBinary(binaryPath) {
+  try {
+    const result = spawnSync(binaryPath, ["--version"], {
+      stdio: "pipe",
+      timeout: 1e4,
+      env: {
+        ...process.env,
+        TESSL_AUTO_UPDATE_INTERVAL_MINUTES: "0"
+      }
+    });
+    if (result.error) {
+      return { success: false, error: result.error.message };
+    }
+    if (result.status !== 0) {
+      return {
+        success: false,
+        error: `--version exited with code ${result.status}`
+      };
+    }
+    return { success: true };
+  } catch (err) {
+    return {
+      success: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+
+// installer/src/path.ts
+var pathSeq = 0;
+var nextPathSeq = () => pathSeq += 1;
 function getAppDataDir() {
   if (process.platform === "win32") {
     return process.env.LOCALAPPDATA ?? join(homedir(), "AppData", "Local");
@@ -163,11 +199,29 @@ function getTesslBinPath() {
 function getVersionsDirectory() {
   return join(getAppDataDir(), "tessl", "versions");
 }
+function getStagedVersionsDirectory() {
+  return join(getAppDataDir(), "tessl", "staged-versions");
+}
+function getStagingDirForRun() {
+  return join(getStagedVersionsDirectory(), `${Date.now()}-${process.pid}-${nextPathSeq()}`);
+}
 function getVersionedBinPath(version, platform) {
   const base = `tessl-${version}-${platform}`;
   const name = platform.startsWith("win32") ? `${base}.exe` : base;
   return join(getVersionsDirectory(), name);
 }
+async function promoteStagedBinary({
+  stagedBinPath,
+  versionedBinPath,
+  versionsDir
+}) {
+  const validation = validateBinary(stagedBinPath);
+  if (!validation.success) {
+    throw new Error(`${validation.error}. Please try again.`);
+  }
+  await mkdir2(versionsDir, { recursive: true });
+  await rename(stagedBinPath, versionedBinPath);
+}
 async function getExistingBinaryPath(tesslBinPath) {
   if (!existsSync(tesslBinPath)) {
     return null;
@@ -186,22 +240,28 @@ async function getExistingBinaryPath(tesslBinPath) {
     return null;
   }
 }
-async function updateBinaryAtomic(versionedBinPath, tesslBinPath) {
+async function updateBinaryAtomic({
+  versionedBinPath,
+  tesslBinPath
+}) {
   await mkdir2(dirname(tesslBinPath), { recursive: true });
-  const tempPath = `${tesslBinPath}.tmp`;
+  const tag = `${Date.now()}-${process.pid}-${nextPathSeq()}`;
+  const tempPath = `${tesslBinPath}.tmp.${tag}`;
   if (process.platform === "win32") {
-    const oldPath = `${tesslBinPath}.old.${Date.now()}`;
+    const oldPath = `${tesslBinPath}.old.${tag}`;
     await copyFile(versionedBinPath, tempPath);
     try {
       await rename(tesslBinPath, oldPath);
     } catch (e) {
       if (e.code !== "ENOENT") {
+        await unlink(tempPath).catch(() => {});
         throw e;
       }
     }
     try {
       await rename(tempPath, tesslBinPath);
     } catch (e) {
+      await unlink(tempPath).catch(() => {});
       try {
         await rename(oldPath, tesslBinPath);
       } catch {}
@@ -214,7 +274,12 @@ async function updateBinaryAtomic(versionedBinPath, tesslBinPath) {
     await unlink(tempPath);
   } catch {}
   await symlink(versionedBinPath, tempPath);
-  await rename(tempPath, tesslBinPath);
+  try {
+    await rename(tempPath, tesslBinPath);
+  } catch (e) {
+    await unlink(tempPath).catch(() => {});
+    throw e;
+  }
 }
 async function pruneOldBackups(binDir, tesslBinPath) {
   try {
@@ -328,36 +393,6 @@ function spawnBinary(binaryPath, args) {
   });
 }
 
-// installer/src/validate.ts
-import { spawnSync } from "node:child_process";
-function validateBinary(binaryPath) {
-  try {
-    const result = spawnSync(binaryPath, ["--version"], {
-      stdio: "pipe",
-      timeout: 1e4,
-      env: {
-        ...process.env,
-        TESSL_AUTO_UPDATE_INTERVAL_MINUTES: "0"
-      }
-    });
-    if (result.error) {
-      return { success: false, error: result.error.message };
-    }
-    if (result.status !== 0) {
-      return {
-        success: false,
-        error: `--version exited with code ${result.status}`
-      };
-    }
-    return { success: true };
-  } catch (err) {
-    return {
-      success: false,
-      error: err instanceof Error ? err.message : String(err)
-    };
-  }
-}
-
 // installer/src/verify.ts
 import { createHash, verify } from "node:crypto";
 function parseManifest(manifest) {
@@ -399,7 +434,12 @@ function sha256Hex(data) {
 function isInteractive() {
   return process.stdin.isTTY === true && process.stdout.isTTY === true;
 }
-async function downloadVerifyAndExtract(version, platform, tarballUrl, versionsDir) {
+async function downloadVerifyAndExtract({
+  version,
+  platform,
+  tarballUrl,
+  destination
+}) {
   const fileName = getBinaryFileName(version, platform);
   const [tarballBytes, manifestBytes, manifestSig] = await Promise.all([
     downloadBytes(tarballUrl),
@@ -415,7 +455,7 @@ async function downloadVerifyAndExtract(version, platform, tarballUrl, versionsD
     throw new Error(`Checksum mismatch for ${fileName} (expected ${expected}, got ${actual}) — refusing to install.`);
   }
   const verifiedStream = Readable2.toWeb(Readable2.from(tarballBytes));
-  await extractTarball(verifiedStream, versionsDir);
+  await extractTarball(verifiedStream, destination);
 }
 async function promptConfirmation(message) {
   return new Promise((resolve2) => {
@@ -441,7 +481,7 @@ function printUnsupportedPlatformMessage() {
 async function prepareBinary() {
   const tesslBinPath = getTesslBinPath();
   const existingBinary = await getExistingBinaryPath(tesslBinPath);
-  const installerVersion = "0.92.0";
+  const installerVersion = "0.94.0";
   const isTestOrDevBuild = installerVersion.includes("test") || installerVersion.includes("dev");
   let versionMismatch = false;
   if (isTestOrDevBuild && existingBinary) {
@@ -471,28 +511,31 @@ async function prepareBinary() {
   console.log(`Downloading ${version} for ${platform}`);
   const url = getBinaryUrl(version, platform);
   const versionsDir = getVersionsDirectory();
+  const stagingDir = getStagingDirForRun();
+  const stagedBinPath = join2(stagingDir, basename2(versionedBinPath));
   const progressInterval = setInterval(() => process.stdout.write("."), 500).unref();
   try {
+    await mkdir3(stagingDir, { recursive: true });
     if (RELEASE_VERIFICATION_ENABLED) {
-      await downloadVerifyAndExtract(version, platform, url, versionsDir);
+      await downloadVerifyAndExtract({
+        version,
+        platform,
+        tarballUrl: url,
+        destination: stagingDir
+      });
     } else {
       const tarballStream = await downloadTarball(url);
-      await extractTarball(tarballStream, versionsDir);
+      await extractTarball(tarballStream, stagingDir);
     }
+    await promoteStagedBinary({ stagedBinPath, versionedBinPath, versionsDir });
   } finally {
     clearInterval(progressInterval);
     console.log("");
-  }
-  const validation = validateBinary(versionedBinPath);
-  if (!validation.success) {
-    try {
-      rmSync(versionedBinPath, { force: true });
-    } catch {}
-    throw new Error(`${validation.error}. Removed the corrupt file — please try again.`);
+    await rm2(stagingDir, { recursive: true, force: true }).catch(() => {});
   }
   const shouldInstall = !isInteractive() || await promptConfirmation(`Install Tessl CLI to ${tesslBinPath}?`);
   if (shouldInstall) {
-    await updateBinaryAtomic(versionedBinPath, tesslBinPath);
+    await updateBinaryAtomic({ versionedBinPath, tesslBinPath });
     if (platform.includes("musl")) {
       console.log(`
 This system requires libgcc and libstdc++. Install these using your distribution's package manager.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tessl",
-  "version": "0.92.0",
+  "version": "0.94.0",
   "description": "Tessl CLI",
   "author": "Tessl",
   "license": "SEE LICENSE.md",