tessl 0.75.0 → 0.77.0

package/bin/tessl.js

@@ -51,6 +51,7 @@ async function downloadTarball(url) {
 // installer/src/extract.ts
 import { spawn } from "node:child_process";
 import { mkdir } from "node:fs/promises";
+import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 async function extractTarball(stream, destination) {
   await mkdir(destination, { recursive: true });
@@ -70,34 +71,114 @@ async function extractTarball(stream, destination) {
     });
     tar.on("error", reject);
   });
-  await pipeline(stream, tar.stdin);
+  await pipeline(Readable.fromWeb(stream), tar.stdin);
   await tarExit;
 }
 
-// installer/src/paths.ts
+// installer/src/path.ts
+import { existsSync } from "node:fs";
+import {
+  copyFile,
+  mkdir as mkdir2,
+  readdir,
+  readlink,
+  rename,
+  rm,
+  symlink,
+  unlink
+} from "node:fs/promises";
 import { homedir } from "node:os";
-import { join } from "node:path";
-function getXdgDataHome() {
+import { basename, dirname, join, resolve } from "node:path";
+function getAppDataDir() {
+  if (process.platform === "win32") {
+    return process.env.LOCALAPPDATA ?? join(homedir(), "AppData", "Local");
+  }
   return process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share");
 }
-function getSymlinkPath() {
+function getTesslBinPath() {
+  if (process.platform === "win32") {
+    return join(getAppDataDir(), "tessl", "bin", "tessl.exe");
+  }
   return join(homedir(), ".local", "bin", "tessl");
 }
 function getVersionsDirectory() {
-  return join(getXdgDataHome(), "tessl", "versions");
+  return join(getAppDataDir(), "tessl", "versions");
+}
+function getVersionedBinPath(version, platform) {
+  const base = `tessl-${version}-${platform}`;
+  const name = platform.startsWith("win32") ? `${base}.exe` : base;
+  return join(getVersionsDirectory(), name);
+}
+async function getExistingBinaryPath(tesslBinPath) {
+  if (!existsSync(tesslBinPath)) {
+    return null;
+  }
+  if (process.platform === "win32") {
+    return tesslBinPath;
+  }
+  try {
+    const target = await readlink(tesslBinPath);
+    const resolvedPath = resolve(dirname(tesslBinPath), target);
+    if (!existsSync(resolvedPath)) {
+      return null;
+    }
+    return resolvedPath;
+  } catch {
+    return null;
+  }
 }
-function getBinaryPath(version, platform) {
-  return join(getVersionsDirectory(), `tessl-${version}-${platform}`);
+async function updateBinaryAtomic(versionedBinPath, tesslBinPath) {
+  await mkdir2(dirname(tesslBinPath), { recursive: true });
+  const tempPath = `${tesslBinPath}.tmp`;
+  if (process.platform === "win32") {
+    const oldPath = `${tesslBinPath}.old.${Date.now()}`;
+    await copyFile(versionedBinPath, tempPath);
+    try {
+      await rename(tesslBinPath, oldPath);
+    } catch (e) {
+      if (e.code !== "ENOENT") {
+        throw e;
+      }
+    }
+    try {
+      await rename(tempPath, tesslBinPath);
+    } catch (e) {
+      try {
+        await rename(oldPath, tesslBinPath);
+      } catch {}
+      throw e;
+    }
+    await pruneOldBackups(dirname(tesslBinPath), tesslBinPath);
+    return;
+  }
+  try {
+    await unlink(tempPath);
+  } catch {}
+  await symlink(versionedBinPath, tempPath);
+  await rename(tempPath, tesslBinPath);
+}
+async function pruneOldBackups(binDir, tesslBinPath) {
+  try {
+    const prefix = `${basename(tesslBinPath)}.old.`;
+    const entries = await readdir(binDir);
+    for (const entry of entries) {
+      if (entry.startsWith(prefix)) {
+        try {
+          await rm(join(binDir, entry), { force: true });
+        } catch {}
+      }
+    }
+  } catch {}
 }
 
 // installer/src/platform.ts
 import { execSync } from "node:child_process";
-import { existsSync } from "node:fs";
+import { existsSync as existsSync2 } from "node:fs";
 function getLibcVariant() {
   if (process.platform !== "linux")
     return null;
   try {
-    if (existsSync("/etc/alpine-release"))
+    if (existsSync2("/etc/alpine-release"))
       return "musl";
   } catch {}
   try {
@@ -127,6 +208,12 @@ function getPlatformString() {
       return variant === "musl" ? "linux-arm64-musl" : "linux-arm64";
     }
   }
+  if (platform === "win32") {
+    if (arch === "x64")
+      return "win32-x64";
+    if (arch === "arm64")
+      return "win32-arm64";
+  }
   return null;
 }
 function getPlatformDescription() {
@@ -157,7 +244,7 @@ function spawnBinary(binaryPath, args) {
       TESSL_MANAGED_BY_NPM: "1"
     }
   });
-  const signals = ["SIGINT", "SIGTERM", "SIGHUP"];
+  const signals = process.platform === "win32" ? ["SIGINT", "SIGTERM", "SIGBREAK"] : ["SIGINT", "SIGTERM", "SIGHUP"];
   const handlers = new Map;
   for (const signal of signals) {
     const handler = () => {
@@ -182,35 +269,6 @@ function spawnBinary(binaryPath, args) {
   });
 }
 
-// installer/src/symlink.ts
-import { existsSync as existsSync2 } from "node:fs";
-import { symlink, rename, unlink, mkdir as mkdir2, readlink } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
-async function getExistingBinaryPath(symlinkPath) {
-  if (!existsSync2(symlinkPath)) {
-    return null;
-  }
-  try {
-    const binaryPath = await readlink(symlinkPath);
-    const resolvedPath = resolve(dirname(symlinkPath), binaryPath);
-    if (!existsSync2(resolvedPath)) {
-      return null;
-    }
-    return resolvedPath;
-  } catch {
-    return null;
-  }
-}
-async function createSymlinkAtomic(target, linkPath) {
-  const tempPath = `${linkPath}.tmp`;
-  await mkdir2(dirname(linkPath), { recursive: true });
-  try {
-    await unlink(tempPath);
-  } catch {}
-  await symlink(target, tempPath);
-  await rename(tempPath, linkPath);
-}
-
 // installer/src/validate.ts
 import { spawnSync } from "node:child_process";
 function validateBinary(binaryPath) {
@@ -218,7 +276,10 @@ function validateBinary(binaryPath) {
     const result = spawnSync(binaryPath, ["--version"], {
       stdio: "pipe",
       timeout: 1e4,
-      env: { ...process.env, TESSL_AUTO_UPDATE_INTERVAL_MINUTES: "0" }
+      env: {
+        ...process.env,
+        TESSL_AUTO_UPDATE_INTERVAL_MINUTES: "0"
+      }
     });
     if (result.error) {
       return { success: false, error: result.error.message };
@@ -260,27 +321,28 @@ function printUnsupportedPlatformMessage() {
   console.error(`Tessl CLI binaries are available for:
     - macOS (ARM64, x64)
     - Linux (x64, ARM64)
+    - Windows (x64, ARM64)
   `);
 }
 async function prepareBinary() {
-  const symlinkPath = getSymlinkPath();
-  const symlinkTarget = await getExistingBinaryPath(symlinkPath);
-  const installerVersion = "0.75.0";
+  const tesslBinPath = getTesslBinPath();
+  const existingBinary = await getExistingBinaryPath(tesslBinPath);
+  const installerVersion = "0.77.0";
   const isTestOrDevBuild = installerVersion.includes("test") || installerVersion.includes("dev");
-  let symlinkMismatch = false;
-  if (isTestOrDevBuild && symlinkTarget) {
+  let versionMismatch = false;
+  if (isTestOrDevBuild && existingBinary) {
     const platform2 = getPlatformString();
     if (!platform2) {
       printUnsupportedPlatformMessage();
       return process.exit(1);
     }
-    if (symlinkTarget !== getBinaryPath(installerVersion, platform2)) {
+    if (existingBinary !== getVersionedBinPath(installerVersion, platform2)) {
       console.log(`Test/dev build - switching to version: ${installerVersion}`);
-      symlinkMismatch = true;
+      versionMismatch = true;
     }
   }
-  if (symlinkTarget && !symlinkMismatch) {
-    return symlinkPath;
+  if (existingBinary && !versionMismatch) {
+    return tesslBinPath;
   }
   const platform = getPlatformString();
   if (!platform) {
@@ -288,9 +350,9 @@ async function prepareBinary() {
     return process.exit(1);
   }
   const version = isTestOrDevBuild ? installerVersion : await fetchLatestVersion(getChannelFromVersion(installerVersion));
-  const binaryPath = getBinaryPath(version, platform);
-  if (existsSync3(binaryPath)) {
-    return binaryPath;
+  const versionedBinPath = getVersionedBinPath(version, platform);
+  if (existsSync3(versionedBinPath)) {
+    return versionedBinPath;
   }
   console.log(`Downloading ${version} for ${platform}`);
   const url = getBinaryUrl(version, platform);
@@ -303,25 +365,25 @@ async function prepareBinary() {
     clearInterval(progressInterval);
     console.log("");
   }
-  const validation = validateBinary(binaryPath);
+  const validation = validateBinary(versionedBinPath);
   if (!validation.success) {
     try {
-      rmSync(binaryPath, { force: true });
+      rmSync(versionedBinPath, { force: true });
     } catch {}
     throw new Error(`${validation.error}. Removed the corrupt file — please try again.`);
   }
-  const shouldCreateSymlink = !isInteractive() || await promptConfirmation(`Install Tessl CLI to ${symlinkPath}?`);
-  if (shouldCreateSymlink) {
-    await createSymlinkAtomic(binaryPath, symlinkPath);
+  const shouldInstall = !isInteractive() || await promptConfirmation(`Install Tessl CLI to ${tesslBinPath}?`);
+  if (shouldInstall) {
+    await updateBinaryAtomic(versionedBinPath, tesslBinPath);
     if (platform.includes("musl")) {
       console.log(`
 This system requires libgcc and libstdc++. Install these using your distribution's package manager.
 On Alpine: apk add libgcc libstdc++
 `);
     }
-    return symlinkPath;
+    return tesslBinPath;
   }
-  return binaryPath;
+  return versionedBinPath;
 }
 async function main() {
   const path = await prepareBinary();

package/package.json

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