@akiojin/gwt 6.17.1 → 6.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akiojin/gwt",
-  "version": "6.17.1",
+  "version": "6.19.0",
   "description": "Interactive Git worktree manager with Coding Agent selection (Claude Code / Codex CLI / Gemini CLI)",
   "bin": {
     "gwt": "bin/gwt.js"

package/scripts/postinstall.js

@@ -4,9 +4,16 @@
  * for the current platform from GitHub Releases.
  */
 
-import { createWriteStream, existsSync, mkdirSync, chmodSync, unlinkSync } from 'fs';
+import {
+  createWriteStream,
+  existsSync,
+  mkdirSync,
+  chmodSync,
+  unlinkSync,
+  readFileSync,
+} from 'fs';
 import { dirname, join } from 'path';
-import { fileURLToPath } from 'url';
+import { fileURLToPath, pathToFileURL } from 'url';
 import { get } from 'https';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -17,6 +24,15 @@ const BIN_DIR = join(__dirname, '..', 'bin');
 const BIN_NAME = process.platform === 'win32' ? 'gwt.exe' : 'gwt';
 const BIN_PATH = join(BIN_DIR, BIN_NAME);
 
+const RETRY_CONFIG = {
+  maxAttempts: 5,
+  initialDelayMs: 500,
+  backoffFactor: 2,
+  maxDelayMs: 5000,
+};
+
+const MAX_REDIRECTS = 5;
+
 function getPlatformArtifact() {
   const platform = process.platform;
   const arch = process.arch;
@@ -41,71 +57,162 @@ function getPlatformArtifact() {
   return artifact;
 }
 
-async function getLatestReleaseUrl(artifact) {
-  return new Promise((resolve, reject) => {
+function getPackageVersion() {
+  const packagePath = join(__dirname, '..', 'package.json');
+  const pkg = JSON.parse(readFileSync(packagePath, 'utf8'));
+  if (!pkg.version) {
+    throw new Error('package.json does not contain a version field');
+  }
+  return pkg.version;
+}
+
+function buildReleaseDownloadUrl(version, artifact) {
+  return `https://github.com/${REPO}/releases/download/v${version}/${artifact}`;
+}
+
+function getRetryDelayMs(attempt, config = RETRY_CONFIG) {
+  const delay = config.initialDelayMs * Math.pow(config.backoffFactor, Math.max(0, attempt - 1));
+  return Math.min(delay, config.maxDelayMs);
+}
+
+function isRetryableStatus(statusCode) {
+  return statusCode === 403 || statusCode === 404 || statusCode >= 500;
+}
+
+function isRetryableError(error) {
+  if (error && typeof error.statusCode === 'number') {
+    return isRetryableStatus(error.statusCode);
+  }
+  return true;
+}
+
+function formatFailureGuidance(version, artifact) {
+  const versionedUrl = version && version !== 'unknown'
+    ? buildReleaseDownloadUrl(version, artifact)
+    : null;
+  return {
+    versionedUrl,
+    releasePageUrl: `https://github.com/${REPO}/releases`,
+    buildCommand: 'cargo build --release',
+  };
+}
+
+async function getReleaseAssetUrl(version, artifact, httpGet = get) {
+  return new Promise((resolve) => {
     const options = {
       hostname: 'api.github.com',
-      path: `/repos/${REPO}/releases/latest`,
+      path: `/repos/${REPO}/releases/tags/v${version}`,
       headers: {
         'User-Agent': 'gwt-postinstall',
         'Accept': 'application/vnd.github.v3+json',
       },
     };
 
-    get(options, (res) => {
+    const req = httpGet(options, (res) => {
       let data = '';
       res.on('data', (chunk) => data += chunk);
       res.on('end', () => {
+        if (res.statusCode !== 200) {
+          resolve(null);
+          return;
+        }
         try {
           const release = JSON.parse(data);
-          const asset = release.assets?.find(a => a.name === artifact);
-          if (asset) {
-            resolve(asset.browser_download_url);
-          } else {
-            // Fallback to direct URL pattern
-            resolve(`https://github.com/${REPO}/releases/latest/download/${artifact}`);
-          }
-        } catch (e) {
-          // Fallback to direct URL pattern
-          resolve(`https://github.com/${REPO}/releases/latest/download/${artifact}`);
+          const asset = release.assets?.find((entry) => entry.name === artifact);
+          resolve(asset?.browser_download_url ?? null);
+        } catch {
+          resolve(null);
         }
       });
-    }).on('error', reject);
+    });
+
+    req.on('error', () => resolve(null));
   });
 }
 
-async function downloadFile(url, dest) {
+async function getDownloadUrl(version, artifact) {
+  const assetUrl = await getReleaseAssetUrl(version, artifact);
+  return assetUrl ?? buildReleaseDownloadUrl(version, artifact);
+}
+
+async function downloadFile(url, dest, httpGet = get) {
   return new Promise((resolve, reject) => {
-    const file = createWriteStream(dest);
+    const request = (currentUrl, redirectCount) => {
+      const req = httpGet(currentUrl, (res) => {
+        const statusCode = res.statusCode ?? 0;
 
-    const request = (url) => {
-      get(url, (res) => {
-        // Handle redirects
-        if (res.statusCode === 301 || res.statusCode === 302) {
-          request(res.headers.location);
+        if ([301, 302, 303, 307, 308].includes(statusCode)) {
+          const location = res.headers.location;
+          res.resume();
+          if (!location) {
+            const error = new Error(`Redirect without location (HTTP ${statusCode})`);
+            error.statusCode = statusCode;
+            reject(error);
+            return;
+          }
+          if (redirectCount >= MAX_REDIRECTS) {
+            const error = new Error('Too many redirects');
+            error.statusCode = statusCode;
+            reject(error);
+            return;
+          }
+          const resolved = new URL(location, currentUrl).toString();
+          request(resolved, redirectCount + 1);
           return;
         }
 
-        if (res.statusCode !== 200) {
-          reject(new Error(`Failed to download: HTTP ${res.statusCode}`));
+        if (statusCode !== 200) {
+          res.resume();
+          const error = new Error(`Failed to download: HTTP ${statusCode}`);
+          error.statusCode = statusCode;
+          reject(error);
           return;
         }
 
+        const file = createWriteStream(dest);
         res.pipe(file);
-        file.on('finish', () => {
-          file.close();
-          resolve();
-        });
-      }).on('error', (err) => {
+
+        const cleanup = (err) => {
+          file.close(() => {
+            if (existsSync(dest)) unlinkSync(dest);
+            reject(err);
+          });
+        };
+
+        file.on('finish', () => file.close(resolve));
+        file.on('error', cleanup);
+        res.on('error', cleanup);
+      });
+
+      req.on('error', (err) => {
         if (existsSync(dest)) unlinkSync(dest);
         reject(err);
       });
     };
 
-    request(url);
+    request(url, 0);
   });
 }
 
+async function downloadWithRetry(url, dest, config = RETRY_CONFIG) {
+  let attempt = 0;
+
+  while (attempt < config.maxAttempts) {
+    attempt += 1;
+    try {
+      await downloadFile(url, dest);
+      return;
+    } catch (error) {
+      if (!isRetryableError(error) || attempt >= config.maxAttempts) {
+        throw error;
+      }
+      const delayMs = getRetryDelayMs(attempt, config);
+      console.log(`Retrying download in ${delayMs}ms (attempt ${attempt}/${config.maxAttempts})...`);
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+  }
+}
+
 async function main() {
   // Skip in CI environments where binary might be built differently
   if (process.env.CI || process.env.GITHUB_ACTIONS) {
@@ -120,17 +227,19 @@ async function main() {
   }
 
   const artifact = getPlatformArtifact();
+  let version = 'unknown';
   console.log(`Downloading gwt binary for ${process.platform}-${process.arch}...`);
 
   try {
-    const url = await getLatestReleaseUrl(artifact);
+    version = getPackageVersion();
+    const url = await getDownloadUrl(version, artifact);
     console.log(`Downloading from: ${url}`);
 
     if (!existsSync(BIN_DIR)) {
       mkdirSync(BIN_DIR, { recursive: true });
     }
 
-    await downloadFile(url, BIN_PATH);
+    await downloadWithRetry(url, BIN_PATH);
 
     // Make executable on Unix
     if (process.platform !== 'win32') {
@@ -139,14 +248,36 @@ async function main() {
 
     console.log('gwt binary installed successfully!');
   } catch (error) {
+    const guidance = formatFailureGuidance(version, artifact);
     console.error('Failed to download gwt binary:', error.message);
     console.error('');
     console.error('You can manually download the binary from:');
-    console.error(`https://github.com/${REPO}/releases`);
+    if (guidance.versionedUrl) {
+      console.error(guidance.versionedUrl);
+    }
+    console.error(guidance.releasePageUrl);
     console.error('');
-    console.error('Or build from source with: cargo build --release');
+    console.error(`Or build from source with: ${guidance.buildCommand}`);
     process.exit(1);
   }
 }
 
-main();
+const isDirectRun = process.argv[1]
+  && pathToFileURL(process.argv[1]).href === import.meta.url;
+
+if (isDirectRun) {
+  main();
+}
+
+export {
+  RETRY_CONFIG,
+  buildReleaseDownloadUrl,
+  formatFailureGuidance,
+  getRetryDelayMs,
+  getReleaseAssetUrl,
+  getDownloadUrl,
+  getPackageVersion,
+  getPlatformArtifact,
+  isRetryableError,
+  isRetryableStatus,
+};

package/scripts/postinstall.test.js

@@ -0,0 +1,57 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  RETRY_CONFIG,
+  buildReleaseDownloadUrl,
+  formatFailureGuidance,
+  getRetryDelayMs,
+  isRetryableError,
+  isRetryableStatus,
+} from './postinstall.js';
+
+test('buildReleaseDownloadUrl uses version tag', () => {
+  const url = buildReleaseDownloadUrl('6.17.0', 'gwt-linux-x86_64');
+  assert.equal(
+    url,
+    'https://github.com/akiojin/gwt/releases/download/v6.17.0/gwt-linux-x86_64',
+  );
+});
+
+test('getRetryDelayMs applies exponential backoff with cap', () => {
+  assert.equal(getRetryDelayMs(1, RETRY_CONFIG), 500);
+  assert.equal(getRetryDelayMs(2, RETRY_CONFIG), 1000);
+  assert.equal(getRetryDelayMs(3, RETRY_CONFIG), 2000);
+  assert.equal(getRetryDelayMs(5, RETRY_CONFIG), 5000);
+});
+
+test('isRetryableStatus matches 403/404/5xx', () => {
+  assert.equal(isRetryableStatus(403), true);
+  assert.equal(isRetryableStatus(404), true);
+  assert.equal(isRetryableStatus(500), true);
+  assert.equal(isRetryableStatus(429), false);
+  assert.equal(isRetryableStatus(400), false);
+});
+
+test('isRetryableError uses statusCode or treats network errors as retryable', () => {
+  const notFound = new Error('not found');
+  notFound.statusCode = 404;
+  assert.equal(isRetryableError(notFound), true);
+
+  const badRequest = new Error('bad request');
+  badRequest.statusCode = 400;
+  assert.equal(isRetryableError(badRequest), false);
+
+  const networkError = new Error('socket hang up');
+  assert.equal(isRetryableError(networkError), true);
+});
+
+test('formatFailureGuidance includes versioned URL and release page', () => {
+  const guidance = formatFailureGuidance('1.2.3', 'gwt-linux-x86_64');
+  assert.equal(
+    guidance.versionedUrl,
+    'https://github.com/akiojin/gwt/releases/download/v1.2.3/gwt-linux-x86_64',
+  );
+  assert.equal(guidance.releasePageUrl, 'https://github.com/akiojin/gwt/releases');
+  assert.equal(guidance.buildCommand, 'cargo build --release');
+});