@akiojin/gwt 9.5.2 → 9.6.0

package/bin/gwt.cjs

@@ -8,79 +8,40 @@
 const { spawn } = require("child_process");
 const path = require("path");
 const fs = require("fs");
-const https = require("https");
-const os = require("os");
+
+const {
+  binaryNameForPlatform,
+  installReleaseBinary,
+  releaseAssetUrl,
+} = require("../scripts/release-assets.cjs");
 
 const REPO = "akiojin/gwt";
 const BIN_DIR = __dirname;
-const BIN_NAME = process.platform === "win32" ? "gwt.exe" : "gwt";
+const BIN_NAME = binaryNameForPlatform(process.platform);
 const BIN_PATH = path.join(BIN_DIR, BIN_NAME);
 
-function releaseAssetName() {
-  const platform = os.platform();
-  const arch = os.arch();
-
-  if (platform === "darwin" && arch === "arm64") return "gwt-macos-aarch64";
-  if (platform === "darwin" && arch === "x64") return "gwt-macos-x86_64";
-  if (platform === "linux" && arch === "x64") return "gwt-linux-x86_64";
-  if (platform === "linux" && arch === "arm64") return "gwt-linux-aarch64";
-  if (platform === "win32" && arch === "x64") return "gwt-windows-x86_64.exe";
-
-  console.error(`Unsupported platform: ${platform}-${arch}`);
-  process.exit(1);
-}
-
 function readVersion() {
   const pkg = path.join(__dirname, "..", "package.json");
   return JSON.parse(fs.readFileSync(pkg, "utf8")).version;
 }
 
-function download(url, dest) {
-  return new Promise((resolve, reject) => {
-    const file = fs.createWriteStream(dest);
-    const request = (u) => {
-      https
-        .get(u, { headers: { "User-Agent": "gwt-postinstall" } }, (res) => {
-          if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-            request(res.headers.location);
-            return;
-          }
-          if (res.statusCode !== 200) {
-            file.close();
-            fs.unlink(dest, () => {});
-            reject(new Error(`HTTP ${res.statusCode} for ${u}`));
-            return;
-          }
-          res.pipe(file);
-          file.on("finish", () => file.close(resolve));
-        })
-        .on("error", (err) => {
-          file.close();
-          fs.unlink(dest, () => {});
-          reject(err);
-        });
-    };
-    request(url);
-  });
-}
-
 async function ensureBinary() {
   if (fs.existsSync(BIN_PATH)) return;
 
   const version = readVersion();
-  const asset = releaseAssetName();
-  const tag = `v${version}`;
-  const url = `https://github.com/${REPO}/releases/download/${tag}/${asset}`;
+  const { url } = releaseAssetUrl(REPO, version, process.platform, process.arch);
 
-  console.log(`Downloading gwt binary for ${os.platform()}-${os.arch()}...`);
+  console.log(`Downloading gwt binary for ${process.platform}-${process.arch}...`);
   console.log(`Downloading from: ${url}`);
 
-  fs.mkdirSync(BIN_DIR, { recursive: true });
-  await download(url, BIN_PATH);
-
-  if (os.platform() !== "win32") {
-    fs.chmodSync(BIN_PATH, 0o755);
-  }
+  await installReleaseBinary({
+    repo: REPO,
+    version,
+    binDir: BIN_DIR,
+    binaryName: BIN_NAME,
+    platform: process.platform,
+    arch: process.arch,
+  });
 
   console.log("gwt binary installed successfully!");
 }
@@ -113,4 +74,12 @@ async function main() {
   });
 }
 
-main();
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  ensureBinary,
+  main,
+  readVersion,
+};

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@akiojin/gwt",
-  "version": "9.5.2",
+  "version": "9.6.0",
   "description": "Desktop GUI for Git worktree management and coding agent launch",
   "type": "module",
   "bin": {
     "gwt": "bin/gwt.cjs"
   },
   "scripts": {
-    "postinstall": "node scripts/postinstall.js",
+    "postinstall": "node scripts/postinstall.cjs",
     "dev": "cargo run -p gwt",
     "build": "cargo build --release -p gwt",
     "test": "cargo test -p gwt-core -p gwt --all-features",

package/scripts/postinstall.cjs

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+const {
+  binaryNameForPlatform,
+  installReleaseBinary,
+  releaseAssetUrl,
+} = require("./release-assets.cjs");
+
+const REPO = "akiojin/gwt";
+const BIN_DIR = path.join(__dirname, "..", "bin");
+const BINARY_NAME = binaryNameForPlatform();
+
+function readVersion() {
+  const pkg = path.join(__dirname, "..", "package.json");
+  const data = JSON.parse(fs.readFileSync(pkg, "utf8"));
+  return data.version;
+}
+
+async function main() {
+  if (process.env.CI) {
+    console.log("gwt: skipping binary download in CI");
+    return;
+  }
+
+  const version = readVersion();
+  const { url } = releaseAssetUrl(REPO, version);
+
+  console.log(`Downloading gwt binary for ${process.platform}-${process.arch}...`);
+  console.log(`Downloading from: ${url}`);
+
+  try {
+    await installReleaseBinary({
+      repo: REPO,
+      version,
+      binDir: BIN_DIR,
+      binaryName: BINARY_NAME,
+    });
+    console.log("gwt binary installed successfully!");
+  } catch (err) {
+    console.error(`gwt: failed to download binary - ${err.message}`);
+    console.error("gwt: you can build from source with: cargo build --release -p gwt");
+    process.exitCode = 0;
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  main,
+  readVersion,
+};

package/scripts/release-assets.cjs

@@ -0,0 +1,189 @@
+const fs = require("fs");
+const https = require("https");
+const os = require("os");
+const path = require("path");
+const { execFileSync } = require("child_process");
+
+function binaryNameForPlatform(platform = os.platform()) {
+  return platform === "win32" ? "gwt.exe" : "gwt";
+}
+
+function releaseAssetName(platform = os.platform(), arch = os.arch()) {
+  if (platform === "darwin" && arch === "arm64") {
+    return "gwt-macos-arm64.tar.gz";
+  }
+  if (platform === "darwin" && arch === "x64") {
+    return "gwt-macos-x86_64.tar.gz";
+  }
+  if (platform === "linux" && arch === "x64") {
+    return "gwt-linux-x86_64.tar.gz";
+  }
+  if (platform === "linux" && arch === "arm64") {
+    return "gwt-linux-aarch64.tar.gz";
+  }
+  if (platform === "win32" && arch === "x64") {
+    return "gwt-windows-x86_64.zip";
+  }
+
+  throw new Error(`Unsupported platform: ${platform}-${arch}`);
+}
+
+function releaseAssetUrl(repo, version, platform = os.platform(), arch = os.arch()) {
+  const asset = releaseAssetName(platform, arch);
+  const tag = `v${version}`;
+  return {
+    asset,
+    tag,
+    url: `https://github.com/${repo}/releases/download/${tag}/${asset}`,
+  };
+}
+
+function download(url, dest) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(dest);
+    const request = (nextUrl) => {
+      https
+        .get(nextUrl, { headers: { "User-Agent": "gwt-postinstall" } }, (res) => {
+          if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+            request(res.headers.location);
+            return;
+          }
+          if (res.statusCode !== 200) {
+            file.close();
+            fs.rmSync(dest, { force: true });
+            reject(new Error(`Download failed: HTTP ${res.statusCode} for ${nextUrl}`));
+            return;
+          }
+          res.pipe(file);
+          file.on("finish", () => {
+            file.close(resolve);
+          });
+        })
+        .on("error", (err) => {
+          file.close();
+          fs.rmSync(dest, { force: true });
+          reject(err);
+        });
+    };
+    request(url);
+  });
+}
+
+function findFileRecursive(root, fileName) {
+  const entries = fs.readdirSync(root, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(root, entry.name);
+    if (entry.isFile() && entry.name === fileName) {
+      return fullPath;
+    }
+    if (entry.isDirectory()) {
+      const nested = findFileRecursive(fullPath, fileName);
+      if (nested) {
+        return nested;
+      }
+    }
+  }
+  return null;
+}
+
+function extractArchive(archivePath, extractDir, asset) {
+  if (asset.endsWith(".zip")) {
+    execFileSync(
+      "powershell.exe",
+      [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        `Expand-Archive -LiteralPath '${archivePath.replace(/'/g, "''")}' -DestinationPath '${extractDir.replace(/'/g, "''")}' -Force`,
+      ]
+    );
+    return;
+  }
+
+  if (asset.endsWith(".tar.gz")) {
+    execFileSync("tar", ["-xzf", archivePath, "-C", extractDir]);
+    return;
+  }
+
+  throw new Error(`Unsupported archive type: ${asset}`);
+}
+
+function cleanupTempDir(tempRoot) {
+  if (os.platform() === "win32") {
+    return;
+  }
+
+  try {
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+  } catch {
+    // Best-effort cleanup only.
+  }
+}
+
+function installBinaryFromArchive({
+  archivePath,
+  asset,
+  binDir,
+  binaryName = binaryNameForPlatform(),
+  platform = os.platform(),
+}) {
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "gwt-extract-"));
+  const extractDir = path.join(tempRoot, "extract");
+  const dest = path.join(binDir, binaryName);
+
+  fs.mkdirSync(binDir, { recursive: true });
+  fs.mkdirSync(extractDir, { recursive: true });
+
+  try {
+    extractArchive(archivePath, extractDir, asset);
+
+    const extractedBinary = findFileRecursive(extractDir, binaryName);
+    if (!extractedBinary) {
+      throw new Error(`Extracted archive does not contain ${binaryName}`);
+    }
+
+    fs.copyFileSync(extractedBinary, dest);
+    if (platform !== "win32") {
+      fs.chmodSync(dest, 0o755);
+    }
+
+    return { asset, dest };
+  } finally {
+    cleanupTempDir(tempRoot);
+  }
+}
+
+async function installReleaseBinary({
+  repo,
+  version,
+  binDir,
+  binaryName = binaryNameForPlatform(),
+  platform = os.platform(),
+  arch = os.arch(),
+}) {
+  const { asset, url } = releaseAssetUrl(repo, version, platform, arch);
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "gwt-release-"));
+  const archivePath = path.join(tempRoot, asset);
+
+  try {
+    await download(url, archivePath);
+    return installBinaryFromArchive({
+      archivePath,
+      asset,
+      binDir,
+      binaryName,
+      platform,
+    });
+  } finally {
+    cleanupTempDir(tempRoot);
+  }
+}
+
+module.exports = {
+  binaryNameForPlatform,
+  download,
+  installBinaryFromArchive,
+  installReleaseBinary,
+  releaseAssetName,
+  releaseAssetUrl,
+};

package/scripts/test_release_assets.cjs

@@ -0,0 +1,97 @@
+const assert = require("node:assert/strict");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { execFileSync } = require("child_process");
+
+const {
+  binaryNameForPlatform,
+  installBinaryFromArchive,
+  releaseAssetName,
+} = require("./release-assets.cjs");
+const postinstall = require("./postinstall.cjs");
+const launcher = require("../bin/gwt.cjs");
+
+let failed = false;
+
+function run(name, fn) {
+  try {
+    fn();
+    console.log(`ok - ${name}`);
+  } catch (error) {
+    failed = true;
+    console.error(`not ok - ${name}`);
+    console.error(error && error.stack ? error.stack : error);
+  }
+}
+
+run("release asset names match the public portable contract", () => {
+  assert.equal(releaseAssetName("darwin", "arm64"), "gwt-macos-arm64.tar.gz");
+  assert.equal(releaseAssetName("darwin", "x64"), "gwt-macos-x86_64.tar.gz");
+  assert.equal(releaseAssetName("linux", "arm64"), "gwt-linux-aarch64.tar.gz");
+  assert.equal(releaseAssetName("linux", "x64"), "gwt-linux-x86_64.tar.gz");
+  assert.equal(releaseAssetName("win32", "x64"), "gwt-windows-x86_64.zip");
+});
+
+run("release helper keeps platform binary names stable", () => {
+  assert.equal(binaryNameForPlatform("win32"), "gwt.exe");
+  assert.equal(binaryNameForPlatform("linux"), "gwt");
+  assert.equal(binaryNameForPlatform("darwin"), "gwt");
+});
+
+run("installer entrypoints are loadable under package type module", () => {
+  assert.equal(typeof postinstall.main, "function");
+  assert.equal(typeof launcher.main, "function");
+});
+
+run("portable tarball extraction installs the unix binary", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "gwt-release-test-"));
+  const sourceDir = path.join(root, "source");
+  const binDir = path.join(root, "bin");
+  const archivePath = path.join(root, "gwt-linux-x86_64.tar.gz");
+  fs.mkdirSync(sourceDir, { recursive: true });
+  fs.writeFileSync(path.join(sourceDir, "gwt"), "unix-binary");
+
+  execFileSync("tar", ["-czf", archivePath, "-C", sourceDir, "gwt"]);
+
+  installBinaryFromArchive({
+    archivePath,
+    asset: path.basename(archivePath),
+    binDir,
+    binaryName: "gwt",
+    platform: "linux",
+  });
+
+  assert.equal(fs.readFileSync(path.join(binDir, "gwt"), "utf8"), "unix-binary");
+});
+
+run("portable zip extraction installs the windows binary", () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "gwt-release-test-"));
+  const sourceDir = path.join(root, "source");
+  const binDir = path.join(root, "bin");
+  const archivePath = path.join(root, "gwt-windows-x86_64.zip");
+  const sourceBinary = path.join(sourceDir, "gwt.exe");
+  fs.mkdirSync(sourceDir, { recursive: true });
+  fs.writeFileSync(sourceBinary, "windows-binary");
+
+  execFileSync("powershell.exe", [
+    "-NoProfile",
+    "-NonInteractive",
+    "-Command",
+    `Compress-Archive -LiteralPath '${sourceBinary.replace(/'/g, "''")}' -DestinationPath '${archivePath.replace(/'/g, "''")}' -Force`,
+  ]);
+
+  installBinaryFromArchive({
+    archivePath,
+    asset: path.basename(archivePath),
+    binDir,
+    binaryName: "gwt.exe",
+    platform: "win32",
+  });
+
+  assert.equal(fs.readFileSync(path.join(binDir, "gwt.exe"), "utf8"), "windows-binary");
+});
+
+if (failed) {
+  process.exit(1);
+}

package/wix/main.wxs

@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Wix xmlns="http://wixtoolset.org/schemas/v4/wxs">
+  <Package
+    Name="GWT"
+    Language="1033"
+    Version="$(Version)"
+    Manufacturer="GWT Contributors"
+    UpgradeCode="55555555-5555-5555-5555-555555555555"
+    InstallerVersion="500"
+    Scope="perMachine">
+    <SummaryInformation Description="Canvas-based floating terminal GUI for Git Worktree Manager" />
+    <MajorUpgrade DowngradeErrorMessage="A newer version of GWT is already installed." />
+    <MediaTemplate EmbedCab="yes" />
+
+    <StandardDirectory Id="ProgramFiles6432Folder">
+      <Directory Id="INSTALLFOLDER" Name="GWT" />
+    </StandardDirectory>
+
+    <Feature Id="MainFeature" Title="GWT" Level="1">
+      <ComponentGroupRef Id="ProductComponents" />
+    </Feature>
+  </Package>
+
+  <Fragment>
+    <ComponentGroup Id="ProductComponents" Directory="INSTALLFOLDER">
+      <Component>
+        <File Id="GwtExecutable" Source="!(bindpath.gwt)gwt.exe" KeyPath="yes" />
+      </Component>
+    </ComponentGroup>
+  </Fragment>
+</Wix>

package/scripts/postinstall.js

@@ -1,115 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-
-const os = require("os");
-const fs = require("fs");
-const path = require("path");
-const https = require("https");
-
-const REPO = "akiojin/gwt";
-const BIN_DIR = path.join(__dirname, "..", "bin");
-const BINARY_NAME = os.platform() === "win32" ? "gwt.exe" : "gwt";
-
-/**
- * Detect the GitHub Release asset name for the current platform/arch.
- * Matches the naming convention: gwt-{os}-{arch}[.exe]
- */
-function releaseAssetName() {
-  const platform = os.platform();
-  const arch = os.arch();
-
-  if (platform === "darwin" && arch === "arm64") {
-    return "gwt-macos-aarch64";
-  }
-  if (platform === "darwin" && arch === "x64") {
-    return "gwt-macos-x86_64";
-  }
-  if (platform === "linux" && arch === "x64") {
-    return "gwt-linux-x86_64";
-  }
-  if (platform === "linux" && arch === "arm64") {
-    return "gwt-linux-aarch64";
-  }
-  if (platform === "win32" && arch === "x64") {
-    return "gwt-windows-x86_64.exe";
-  }
-
-  throw new Error(`Unsupported platform: ${platform}-${arch}`);
-}
-
-/**
- * Read the target version from package.json.
- */
-function readVersion() {
-  const pkg = path.join(__dirname, "..", "package.json");
-  const data = JSON.parse(fs.readFileSync(pkg, "utf8"));
-  return data.version;
-}
-
-/**
- * Follow redirects and download a URL to a local path.
- */
-function download(url, dest) {
-  return new Promise((resolve, reject) => {
-    const file = fs.createWriteStream(dest);
-    const request = (u) => {
-      https
-        .get(u, { headers: { "User-Agent": "gwt-postinstall" } }, (res) => {
-          if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-            request(res.headers.location);
-            return;
-          }
-          if (res.statusCode !== 200) {
-            file.close();
-            fs.unlink(dest, () => {});
-            reject(new Error(`Download failed: HTTP ${res.statusCode} for ${u}`));
-            return;
-          }
-          res.pipe(file);
-          file.on("finish", () => {
-            file.close(resolve);
-          });
-        })
-        .on("error", (err) => {
-          file.close();
-          fs.unlink(dest, () => {});
-          reject(err);
-        });
-    };
-    request(url);
-  });
-}
-
-async function main() {
-  // Skip in CI or when running from source
-  if (process.env.CI) {
-    console.log("gwt: skipping binary download in CI");
-    return;
-  }
-
-  const version = readVersion();
-  const asset = releaseAssetName();
-  const tag = `v${version}`;
-  const binaryUrl = `https://github.com/${REPO}/releases/download/${tag}/${asset}`;
-
-  fs.mkdirSync(BIN_DIR, { recursive: true });
-
-  const dest = path.join(BIN_DIR, BINARY_NAME);
-
-  console.log(`Downloading gwt binary for ${os.platform()}-${os.arch()}...`);
-  console.log(`Downloading from: ${binaryUrl}`);
-
-  try {
-    await download(binaryUrl, dest);
-    if (os.platform() !== "win32") {
-      fs.chmodSync(dest, 0o755);
-    }
-    console.log(`gwt binary installed successfully!`);
-  } catch (err) {
-    console.error(`gwt: failed to download binary - ${err.message}`);
-    console.error("gwt: you can build from source with: cargo build --release -p gwt");
-    process.exitCode = 0; // non-fatal so npm install does not fail
-  }
-}
-
-main();