@akiojin/gwt 9.5.2 → 9.7.0

package/.husky/pre-push

@@ -6,7 +6,9 @@ echo "Running CI-equivalent lint checks..."
 
 cargo clippy --all-targets --all-features -- -D warnings
 cargo fmt --all -- --check
-bunx --bun markdownlint-cli . --config .markdownlint.json --ignore target --ignore CHANGELOG.md
+cargo llvm-cov -p gwt-core -p gwt --all-features --json --summary-only --output-path target/coverage-summary.json
+node scripts/check-coverage-threshold.mjs target/coverage-summary.json 90
+bunx --bun markdownlint-cli . --config .markdownlint.json --ignore target --ignore CHANGELOG.md --ignore tasks/todo.md
 pnpm lint:skills
 
 echo "All pre-push checks passed."

package/README.ja.md

@@ -66,6 +66,9 @@ gwt board show
 gwt hook workflow-policy
 ```
 
+managed hook と runtime 委譲の入口も引き続き `gwt` です。利用者が別の daemon
+コマンドを手動起動する必要はありません。
+
 ## 基本フロー
 
 1. リポジトリを開く、または前回のプロジェクトを復元する

package/README.md

@@ -68,6 +68,9 @@ gwt board show
 gwt hook workflow-policy
 ```
 
+Managed hooks and runtime delegation continue to enter through `gwt`. There is
+no separate operator-facing daemon command to start by hand.
+
 ## Main Workflow
 
 1. Open a repository directory or restore the previous project.

package/bin/gwt.cjs

@@ -8,81 +8,45 @@
 const { spawn } = require("child_process");
 const path = require("path");
 const fs = require("fs");
-const https = require("https");
-const os = require("os");
+
+const {
+  bundleBinaryNamesForPlatform,
+  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);
-}
+const BUNDLE_BINARIES = bundleBinaryNamesForPlatform(process.platform);
 
 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;
+  if (BUNDLE_BINARIES.every((name) => fs.existsSync(path.join(BIN_DIR, name)))) {
+    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 bundle 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,
+    platform: process.platform,
+    arch: process.arch,
+  });
 
-  console.log("gwt binary installed successfully!");
+  console.log(`gwt bundle installed successfully: ${BUNDLE_BINARIES.join(", ")}`);
 }
 
 async function main() {
@@ -113,4 +77,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.7.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/check-coverage-threshold.mjs

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+
+const [summaryPath, thresholdArg] = process.argv.slice(2);
+
+if (!summaryPath || !thresholdArg) {
+  console.error(
+    "Usage: node scripts/check-coverage-threshold.mjs <summary-json> <threshold>",
+  );
+  process.exit(2);
+}
+
+const threshold = Number(thresholdArg);
+if (!Number.isFinite(threshold)) {
+  console.error(`Invalid threshold: ${thresholdArg}`);
+  process.exit(2);
+}
+
+const report = JSON.parse(fs.readFileSync(summaryPath, "utf8"));
+const files = report.data?.flatMap((entry) => entry.files ?? []) ?? [];
+const ignoredFilePatterns = [/(^|[\\/])gwt[\\/]src[\\/]main\.rs$/i];
+
+let coveredLines = 0;
+let totalLines = 0;
+const excludedFiles = [];
+
+for (const file of files) {
+  const filename = file.filename ?? "";
+  if (ignoredFilePatterns.some((pattern) => pattern.test(filename))) {
+    excludedFiles.push(path.relative(process.cwd(), filename));
+    continue;
+  }
+
+  const lines = file.summary?.lines;
+  if (!lines) {
+    continue;
+  }
+
+  coveredLines += lines.covered;
+  totalLines += lines.count;
+}
+
+if (totalLines === 0) {
+  console.error("Coverage report did not contain any line summary data.");
+  process.exit(1);
+}
+
+const percent = (coveredLines / totalLines) * 100;
+console.log(
+  `Filtered line coverage: ${percent.toFixed(2)}% (${coveredLines}/${totalLines})`,
+);
+if (excludedFiles.length > 0) {
+  console.log(`Excluded from threshold: ${excludedFiles.join(", ")}`);
+}
+
+if (percent + Number.EPSILON < threshold) {
+  console.error(
+    `Coverage threshold not met: required ${threshold.toFixed(2)}%, got ${percent.toFixed(2)}%`,
+  );
+  process.exit(1);
+}
+
+console.log(`Coverage threshold met: ${threshold.toFixed(2)}%`);

package/scripts/postinstall.cjs

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+const {
+  bundleBinaryNamesForPlatform,
+  installReleaseBinary,
+  releaseAssetUrl,
+} = require("./release-assets.cjs");
+
+const REPO = "akiojin/gwt";
+const BIN_DIR = path.join(__dirname, "..", "bin");
+const BUNDLE_BINARIES = bundleBinaryNamesForPlatform();
+
+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 bundle for ${process.platform}-${process.arch}...`);
+  console.log(`Downloading from: ${url}`);
+
+  try {
+    await installReleaseBinary({
+      repo: REPO,
+      version,
+      binDir: BIN_DIR,
+    });
+    console.log(`gwt bundle installed successfully: ${BUNDLE_BINARIES.join(", ")}`);
+  } 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,202 @@
+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 daemonBinaryNameForPlatform(platform = os.platform()) {
+  return platform === "win32" ? "gwtd.exe" : "gwtd";
+}
+
+function bundleBinaryNamesForPlatform(platform = os.platform()) {
+  return [binaryNameForPlatform(platform), daemonBinaryNameForPlatform(platform)];
+}
+
+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 installBundleFromArchive({
+  archivePath,
+  asset,
+  binDir,
+  platform = os.platform(),
+  binaryNames = bundleBinaryNamesForPlatform(platform),
+}) {
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "gwt-extract-"));
+  const extractDir = path.join(tempRoot, "extract");
+
+  fs.mkdirSync(binDir, { recursive: true });
+  fs.mkdirSync(extractDir, { recursive: true });
+
+  try {
+    extractArchive(archivePath, extractDir, asset);
+
+    const destinations = {};
+    for (const binaryName of binaryNames) {
+      const extractedBinary = findFileRecursive(extractDir, binaryName);
+      if (!extractedBinary) {
+        throw new Error(`Extracted archive does not contain ${binaryName}`);
+      }
+
+      const dest = path.join(binDir, binaryName);
+      fs.copyFileSync(extractedBinary, dest);
+      if (platform !== "win32") {
+        fs.chmodSync(dest, 0o755);
+      }
+      destinations[binaryName] = dest;
+    }
+
+    return { asset, destinations };
+  } finally {
+    cleanupTempDir(tempRoot);
+  }
+}
+
+async function installReleaseBinary({
+  repo,
+  version,
+  binDir,
+  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 installBundleFromArchive({
+      archivePath,
+      asset,
+      binDir,
+      platform,
+    });
+  } finally {
+    cleanupTempDir(tempRoot);
+  }
+}
+
+module.exports = {
+  binaryNameForPlatform,
+  bundleBinaryNamesForPlatform,
+  daemonBinaryNameForPlatform,
+  download,
+  installBinaryFromArchive: installBundleFromArchive,
+  installBundleFromArchive,
+  installReleaseBinary,
+  releaseAssetName,
+  releaseAssetUrl,
+};

package/scripts/test_release_assets.cjs

@@ -0,0 +1,123 @@
+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,
+  bundleBinaryNamesForPlatform,
+  installBundleFromArchive,
+  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("release helper keeps bundle binary names stable", () => {
+  assert.deepEqual(bundleBinaryNamesForPlatform("win32"), ["gwt.exe", "gwtd.exe"]);
+  assert.deepEqual(bundleBinaryNamesForPlatform("linux"), ["gwt", "gwtd"]);
+  assert.deepEqual(bundleBinaryNamesForPlatform("darwin"), ["gwt", "gwtd"]);
+});
+
+run("installer entrypoints are loadable under package type module", () => {
+  assert.equal(typeof postinstall.main, "function");
+  assert.equal(typeof launcher.main, "function");
+});
+
+run("windows installer definition includes the gwtd companion binary", () => {
+  const wix = fs.readFileSync(path.join(__dirname, "..", "wix", "main.wxs"), "utf8");
+  assert.match(wix, /gwtd\.exe/);
+});
+
+run("release workflow packages gwtd alongside gwt", () => {
+  const workflow = fs.readFileSync(
+    path.join(__dirname, "..", ".github", "workflows", "release.yml"),
+    "utf8"
+  );
+  assert.match(workflow, /--bin gwt --bin gwtd/);
+  assert.match(workflow, /Compress-Archive -Path @\("dist\/gwt\.exe", "dist\/gwtd\.exe"\)/);
+  assert.match(workflow, /tar -czf \$\{\{ matrix\.archive_name \}\} gwt gwtd/);
+  assert.match(workflow, /Contents\/MacOS\/gwtd/);
+});
+
+run("portable tarball extraction installs the unix bundle", () => {
+  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");
+  fs.writeFileSync(path.join(sourceDir, "gwtd"), "unix-daemon");
+
+  execFileSync("tar", ["-czf", archivePath, "-C", sourceDir, "gwt", "gwtd"]);
+
+  installBundleFromArchive({
+    archivePath,
+    asset: path.basename(archivePath),
+    binDir,
+    platform: "linux",
+  });
+
+  assert.equal(fs.readFileSync(path.join(binDir, "gwt"), "utf8"), "unix-binary");
+  assert.equal(fs.readFileSync(path.join(binDir, "gwtd"), "utf8"), "unix-daemon");
+});
+
+run("portable zip extraction installs the windows bundle", () => {
+  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");
+  const sourceDaemon = path.join(sourceDir, "gwtd.exe");
+  fs.mkdirSync(sourceDir, { recursive: true });
+  fs.writeFileSync(sourceBinary, "windows-binary");
+  fs.writeFileSync(sourceDaemon, "windows-daemon");
+
+  execFileSync("powershell.exe", [
+    "-NoProfile",
+    "-NonInteractive",
+    "-Command",
+    `Compress-Archive -LiteralPath @('${sourceBinary.replace(/'/g, "''")}','${sourceDaemon.replace(/'/g, "''")}') -DestinationPath '${archivePath.replace(/'/g, "''")}' -Force`,
+  ]);
+
+  installBundleFromArchive({
+    archivePath,
+    asset: path.basename(archivePath),
+    binDir,
+    platform: "win32",
+  });
+
+  assert.equal(fs.readFileSync(path.join(binDir, "gwt.exe"), "utf8"), "windows-binary");
+  assert.equal(fs.readFileSync(path.join(binDir, "gwtd.exe"), "utf8"), "windows-daemon");
+});
+
+if (failed) {
+  process.exit(1);
+}

package/scripts/verify-husky-hooks.sh

@@ -43,7 +43,9 @@ require_contains "$PACKAGE_JSON" "\"lint:husky\": \"bash scripts/verify-husky-ho
 require_file "$PRE_PUSH"
 require_contains "$PRE_PUSH" "cargo clippy --all-targets --all-features -- -D warnings"
 require_contains "$PRE_PUSH" "cargo fmt --all -- --check"
-require_contains "$PRE_PUSH" "bunx --bun markdownlint-cli . --config .markdownlint.json --ignore target --ignore CHANGELOG.md"
+require_contains "$PRE_PUSH" "cargo llvm-cov -p gwt-core -p gwt --all-features --json --summary-only --output-path target/coverage-summary.json"
+require_contains "$PRE_PUSH" "node scripts/check-coverage-threshold.mjs target/coverage-summary.json 90"
+require_contains "$PRE_PUSH" "bunx --bun markdownlint-cli . --config .markdownlint.json --ignore target --ignore CHANGELOG.md --ignore tasks/todo.md"
 require_contains "$PRE_PUSH" "pnpm lint:skills"
 
 require_file "$COMMIT_MSG"
@@ -52,8 +54,6 @@ require_contains "$COMMIT_MSG" 'bunx --package @commitlint/cli commitlint --edit
 if [ -f "$PRE_COMMIT" ]; then
   require_contains "$PRE_COMMIT" "pnpm lint:skills"
   require_contains "$PRE_COMMIT" "bash scripts/run-local-backend-tests-on-commit.sh"
-  require_contains "$PRE_COMMIT" "bash scripts/run-local-e2e-on-commit.sh"
-  require_contains "$PRE_COMMIT" "bash scripts/run-local-e2e-coverage-on-commit.sh"
   require_not_contains "$PRE_COMMIT" "cargo clippy --all-targets --all-features -- -D warnings"
   require_not_contains "$PRE_COMMIT" "cargo fmt --all -- --check"
   require_not_contains "$PRE_COMMIT" "markdownlint-cli"

package/wix/main.wxs

@@ -0,0 +1,34 @@
+<?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>
+      <Component>
+        <File Id="GwtdExecutable" Source="!(bindpath.gwt)gwtd.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();