arashi 1.11.2 → 1.12.0

package/README.md

@@ -47,13 +47,21 @@ If curl installation fails, or if the smoke test reports a bad release artifact,
 npm install -g arashi
 ```
 
+The npm package is script-free: it does not require package-manager lifecycle scripts or `postinstall` approval. It installs the lightweight JavaScript entrypoint and wrapper files first, then downloads the matching platform binary on first use.
+
+To preinstall the binary explicitly, run:
+
+```bash
+arashi install
+```
+
 Verify install:
 
 ```bash
 arashi --version
 ```
 
-If npm is unavailable or fails, use the curl installer command above or the manual release instructions in [`docs/INSTALLATION.md`](./docs/INSTALLATION.md).
+If npm is unavailable or binary installation fails, use the curl installer command above or the manual release instructions in [`docs/INSTALLATION.md`](./docs/INSTALLATION.md).
 
 ### Manual install from GitHub Releases
 
@@ -94,6 +102,7 @@ bun run build
 Arashi currently provides these commands:
 
 - `arashi init`
+- `arashi install`
 - `arashi add <git-url>`
 - `arashi clone [--all]`
 - `arashi create <branch>`

package/bin/arashi.js

@@ -1,110 +1,149 @@
 #!/usr/bin/env node
-import { spawn, spawnSync } from "node:child_process";
+import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { formatInstallError, getPlatformInfo, installBinary } from "./install-binary.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
-const argv = process.argv.slice(2);
-const isWindows = process.platform === "win32";
+const currentPlatform = process.platform;
+const currentArch = process.arch;
+const isWindows = currentPlatform === "win32";
 
-const resolveBinaryPath = () => {
-  const defaultBinary = isWindows ? "arashi.bin.exe" : "arashi.bin";
-  const defaultBinaryPath = join(__dirname, defaultBinary);
+export function getDefaultBinaryName(platform = currentPlatform) {
+  return platform === "win32" ? "arashi.bin.exe" : "arashi.bin";
+}
 
-  if (existsSync(defaultBinaryPath)) {
-    return defaultBinaryPath;
-  }
+export function getWrapperName(platform = currentPlatform) {
+  return platform === "win32" ? "arashi.bat" : "arashi";
+}
 
-  if (isWindows) {
-    return join(__dirname, "arashi-windows-x64.exe");
-  }
+export function resolvePlatformBinaryName({ arch = currentArch, platform = currentPlatform } = {}) {
+  return getPlatformInfo({ arch, platform }).binaryName;
+}
 
-  if (process.platform === "darwin" && process.arch === "arm64") {
-    return join(__dirname, "arashi-macos-arm64");
-  }
+export function resolveBinaryPath(options = {}) {
+  const binDir = options.binDir ?? __dirname;
+  const platform = options.platform ?? currentPlatform;
+  const arch = options.arch ?? currentArch;
+  const exists = options.existsSyncImpl ?? existsSync;
+  const defaultBinaryPath = join(binDir, getDefaultBinaryName(platform));
 
-  if (process.platform === "linux" && process.arch === "x64") {
-    return join(__dirname, "arashi-linux-x64");
+  if (exists(defaultBinaryPath)) {
+    return defaultBinaryPath;
   }
 
-  return defaultBinaryPath;
-};
-
-const ensureInstalled = () => {
-  const wrapper = isWindows ? "arashi.bat" : "arashi";
-  const wrapperPath = join(__dirname, wrapper);
-  const postinstallPath = join(__dirname, "..", "scripts", "postinstall.js");
-  const defaultBinary = isWindows ? "arashi.bin.exe" : "arashi.bin";
-  const defaultBinaryPath = join(__dirname, defaultBinary);
-  const platformBinary = (() => {
-    if (isWindows) {
-      return "arashi-windows-x64.exe";
-    }
-
-    if (process.platform === "darwin" && process.arch === "arm64") {
-      return "arashi-macos-arm64";
-    }
-
-    if (process.platform === "linux" && process.arch === "x64") {
-      return "arashi-linux-x64";
-    }
+  try {
+    return join(binDir, resolvePlatformBinaryName({ arch, platform }));
+  } catch {
+    return defaultBinaryPath;
+  }
+}
 
-    return null;
-  })();
-  const platformBinaryPath = platformBinary ? join(__dirname, platformBinary) : null;
-  const binaryExists = () => {
-    if (existsSync(defaultBinaryPath)) {
-      return true;
-    }
+export function hasRunnableBinary(options = {}) {
+  const binDir = options.binDir ?? __dirname;
+  const platform = options.platform ?? currentPlatform;
+  const arch = options.arch ?? currentArch;
+  const exists = options.existsSyncImpl ?? existsSync;
 
-    if (platformBinaryPath && existsSync(platformBinaryPath)) {
-      return true;
-    }
+  if (exists(join(binDir, getDefaultBinaryName(platform)))) {
+    return true;
+  }
 
+  try {
+    return exists(join(binDir, resolvePlatformBinaryName({ arch, platform })));
+  } catch {
     return false;
-  };
-
-  if (existsSync(wrapperPath) && binaryExists()) {
-    return;
   }
-
-  console.log("arashi binary missing; running postinstall to download.");
-  const result = spawnSync(process.execPath, [postinstallPath], { stdio: "inherit" });
-
-  if (result.error) {
-    console.error(`Failed to run postinstall. ${result.error.message}.`);
-    process.exit(1);
+}
+
+export async function ensureInstalled(options = {}) {
+  const binDir = options.binDir ?? __dirname;
+  const rootDir = options.rootDir ?? join(binDir, "..");
+  const platform = options.platform ?? currentPlatform;
+  const arch = options.arch ?? currentArch;
+  const log = options.log ?? console.log;
+  const installBinaryImpl = options.installBinaryImpl ?? installBinary;
+
+  if (hasRunnableBinary({ arch, binDir, existsSyncImpl: options.existsSyncImpl, platform })) {
+    return { status: "already-installed" };
   }
 
-  if (typeof result.status === "number" && result.status !== 0) {
-    process.exit(result.status);
-  }
-};
-
-ensureInstalled();
-const wrapper = isWindows ? "arashi.bat" : "arashi";
-const wrapperPath = join(__dirname, wrapper);
-const binaryPath = resolveBinaryPath();
-
-const child = isWindows
-  ? spawn(binaryPath, argv, {
-    stdio: "inherit",
-    windowsHide: false,
-  })
-  : spawn(wrapperPath, argv, { stdio: "inherit" });
-
-child.on("exit", (code, signal) => {
-  if (typeof code === "number") {
-    process.exit(code);
+  log("arashi binary missing; installing the matching platform binary before continuing.");
+  return installBinaryImpl({ ...options, arch, binDir, log, platform, rootDir });
+}
+
+export function isExplicitInstallCommand(argv) {
+  return argv[0] === "install";
+}
+
+async function runExplicitInstall(options) {
+  const binDir = options.binDir ?? __dirname;
+  const rootDir = options.rootDir ?? join(binDir, "..");
+  const installBinaryImpl = options.installBinaryImpl ?? installBinary;
+
+  await installBinaryImpl({ ...options, binDir, rootDir });
+}
+
+function spawnArashi(argv, options = {}) {
+  const binDir = options.binDir ?? __dirname;
+  const platform = options.platform ?? currentPlatform;
+  const windows = platform === "win32";
+  const spawnImpl = options.spawnImpl ?? spawn;
+  const wrapperPath = join(binDir, getWrapperName(platform));
+  const binaryPath = resolveBinaryPath({
+    arch: options.arch,
+    binDir,
+    existsSyncImpl: options.existsSyncImpl,
+    platform,
+  });
+
+  return new Promise((resolve) => {
+    const child = windows
+      ? spawnImpl(binaryPath, argv, {
+        stdio: "inherit",
+        windowsHide: false,
+      })
+      : spawnImpl(wrapperPath, argv, { stdio: "inherit" });
+
+    child.on("exit", (code, signal) => {
+      if (typeof code === "number") {
+        resolve(code);
+        return;
+      }
+
+      resolve(signal ? 1 : 0);
+    });
+
+    child.on("error", (error) => {
+      const errorLog = options.error ?? console.error;
+      errorLog(`Failed to start arashi. ${error.message}.`);
+      resolve(1);
+    });
+  });
+}
+
+export async function runEntrypoint(argv = process.argv.slice(2), options = {}) {
+  const errorLog = options.error ?? console.error;
+
+  try {
+    if (isExplicitInstallCommand(argv)) {
+      await runExplicitInstall(options);
+      return 0;
+    }
+
+    await ensureInstalled(options);
+  } catch (error) {
+    errorLog(formatInstallError(error));
+    return 1;
   }
 
-  process.exit(signal ? 1 : 0);
-});
+  return spawnArashi(argv, options);
+}
 
-child.on("error", (error) => {
-  console.error(`Failed to start arashi. ${error.message}.`);
-  process.exit(1);
-});
+const invokedPath = process.argv[1] ? pathToFileURL(process.argv[1]).href : "";
+if (import.meta.url === invokedPath) {
+  process.exitCode = await runEntrypoint();
+}

package/bin/install-binary.js

@@ -0,0 +1,211 @@
+import { spawnSync } from "node:child_process";
+import { chmodSync, createWriteStream } from "node:fs";
+import { access, constants, mkdir, readFile, rm } from "node:fs/promises";
+import { get } from "node:https";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+export const PACKAGE_NAME = "arashi";
+export const GITHUB_REPO = "corwinm/arashi";
+export const MANUAL_INSTALL_URL = `https://github.com/${GITHUB_REPO}/releases`;
+
+export class UnsupportedPlatformError extends Error {
+  constructor(platform = process.platform, arch = process.arch) {
+    super(
+      `Unsupported platform: ${platform}-${arch}. Please build from source or file an issue at https://github.com/${GITHUB_REPO}/issues`,
+    );
+    this.name = "UnsupportedPlatformError";
+    this.platform = platform;
+    this.arch = arch;
+  }
+}
+
+export function getPlatformInfo({ platform = process.platform, arch = process.arch } = {}) {
+  if (platform === "darwin" && arch === "arm64") {
+    return { arch, binaryName: `${PACKAGE_NAME}-macos-arm64`, isWindows: false, platform };
+  }
+
+  if (platform === "linux" && arch === "x64") {
+    return { arch, binaryName: `${PACKAGE_NAME}-linux-x64`, isWindows: false, platform };
+  }
+
+  if (platform === "win32" && arch === "x64") {
+    return { arch, binaryName: `${PACKAGE_NAME}-windows-x64.exe`, isWindows: true, platform };
+  }
+
+  throw new UnsupportedPlatformError(platform, arch);
+}
+
+export function buildReleaseAssetUrl(version, binaryName, repo = GITHUB_REPO) {
+  return `https://github.com/${repo}/releases/download/v${version}/${binaryName}`;
+}
+
+export async function readPackageVersion(packageJsonPath, { readFileImpl = readFile } = {}) {
+  const packageJson = JSON.parse(await readFileImpl(packageJsonPath, "utf8"));
+  return packageJson.version;
+}
+
+export async function isBinaryInstalled(binaryPath, { accessImpl = access } = {}) {
+  try {
+    await accessImpl(binaryPath, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function downloadFile(url, dest, options = {}) {
+  const {
+    createWriteStreamImpl = createWriteStream,
+    getImpl = get,
+    log = console.log,
+    maxRedirects = 5,
+  } = options;
+
+  return new Promise((resolve, reject) => {
+    if (maxRedirects < 0) {
+      reject(new Error("Too many redirects while downloading binary"));
+      return;
+    }
+
+    log(`Downloading ${url}...`);
+
+    const file = createWriteStreamImpl(dest);
+    const request = getImpl(url, (response) => {
+      if (
+        response.statusCode === 301 ||
+        response.statusCode === 302 ||
+        response.statusCode === 307 ||
+        response.statusCode === 308
+      ) {
+        file.close();
+        const location = response.headers.location;
+        if (!location) {
+          reject(new Error(`Redirect response from ${url} did not include a location header`));
+          return;
+        }
+
+        downloadFile(location, dest, { ...options, maxRedirects: maxRedirects - 1 })
+          .then(resolve)
+          .catch(reject);
+        return;
+      }
+
+      if (response.statusCode !== 200) {
+        file.close();
+        reject(new Error(`Failed to download: ${response.statusCode} ${response.statusMessage}`));
+        return;
+      }
+
+      response.pipe(file);
+      file.on("finish", () => {
+        file.close(resolve);
+      });
+    });
+
+    request.on("error", (error) => {
+      file.close();
+      reject(error);
+    });
+
+    file.on("error", (error) => {
+      file.close();
+      reject(error);
+    });
+  });
+}
+
+export function verifyBinary(binaryPath, { log = console.log, spawnSyncImpl = spawnSync } = {}) {
+  const result = spawnSyncImpl(binaryPath, ["--version"], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+
+  if (result.status !== 0) {
+    const signalDetail = result.signal ? ` (signal: ${result.signal})` : "";
+    const output = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
+    throw new Error(
+      `Downloaded binary failed smoke test with exit code ${result.status ?? "unknown"}${signalDetail}${output ? `: ${output}` : ""}`,
+    );
+  }
+
+  const versionOutput = (result.stdout ?? "").trim();
+  if (!versionOutput) {
+    throw new Error("Downloaded binary returned success but produced no version output");
+  }
+
+  log(`✓ Verified ${PACKAGE_NAME} executable (${versionOutput})`);
+  return versionOutput;
+}
+
+export async function installBinary(options = {}) {
+  const rootDir = options.rootDir ?? join(__dirname, "..");
+  const binDir = options.binDir ?? join(rootDir, "bin");
+  const packageJsonPath = options.packageJsonPath ?? join(rootDir, "package.json");
+  const log = options.log ?? console.log;
+  const accessImpl = options.accessImpl ?? access;
+  const chmodImpl = options.chmodImpl ?? chmodSync;
+  const downloadFileImpl = options.downloadFileImpl ?? downloadFile;
+  const mkdirImpl = options.mkdirImpl ?? mkdir;
+  const readFileImpl = options.readFileImpl ?? readFile;
+  const rmImpl = options.rmImpl ?? rm;
+  const verifyBinaryImpl = options.verifyBinaryImpl ?? verifyBinary;
+
+  const version = options.version ?? (await readPackageVersion(packageJsonPath, { readFileImpl }));
+  const { binaryName, isWindows } = getPlatformInfo({
+    arch: options.arch ?? process.arch,
+    platform: options.platform ?? process.platform,
+  });
+  const binaryPath = join(binDir, binaryName);
+  const downloadUrl = buildReleaseAssetUrl(version, binaryName, options.repo ?? GITHUB_REPO);
+
+  if (await isBinaryInstalled(binaryPath, { accessImpl })) {
+    log(`✓ Binary already installed at ${binaryPath}`);
+    return { binaryName, binaryPath, downloadUrl, status: "already-installed", version };
+  }
+
+  try {
+    await mkdirImpl(binDir, { recursive: true });
+    await downloadFileImpl(downloadUrl, binaryPath, { log });
+
+    if (!isWindows) {
+      chmodImpl(binaryPath, 0o755);
+    }
+
+    verifyBinaryImpl(binaryPath, { log });
+
+    log(`✓ Successfully installed ${PACKAGE_NAME} v${version}`);
+    log(`  Binary location: ${binaryPath}`);
+    return { binaryName, binaryPath, downloadUrl, status: "installed", version };
+  } catch (error) {
+    await rmImpl(binaryPath, { force: true }).catch(() => {});
+    throw error;
+  }
+}
+
+export function formatInstallError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return [
+    `✗ Failed to install ${PACKAGE_NAME}: ${message}`,
+    "",
+    `You can manually download binaries from: ${MANUAL_INSTALL_URL}`,
+  ].join("\n");
+}
+
+export async function runInstallCli(options = {}) {
+  const errorLog = options.error ?? console.error;
+  try {
+    await installBinary(options);
+    return 0;
+  } catch (error) {
+    errorLog(formatInstallError(error));
+    return 1;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arashi",
-  "version": "1.11.2",
+  "version": "1.12.0",
   "description": "Git worktree manager for meta-repositories - The eye of the storm for your development workflow",
   "keywords": [
     "cli",
@@ -29,9 +29,9 @@
   "files": [
     "bin/arashi",
     "bin/arashi.js",
+    "bin/install-binary.js",
     "bin/arashi.bat",
     "bin/arashi.ps1",
-    "scripts/postinstall.js",
     "schema/config.schema.json",
     "README.md",
     "LICENSE"
@@ -65,7 +65,6 @@
     "format": "oxfmt --config .oxfmtrc.json --write .",
     "format:check": "oxfmt --config .oxfmtrc.json --check .",
     "quality:changed": "bun run scripts/quality/changed-files-quality.ts",
-    "postinstall": "node scripts/postinstall.js",
     "prepublishOnly": "bun run schema:publish",
     "prepare": "husky"
   },
@@ -85,7 +84,7 @@
     "ora": "^8.1.1",
     "oxfmt": "0.28.0",
     "oxlint": "1.43.0",
-    "semantic-release": "^24.2.0",
+    "semantic-release": "^25.0.3",
     "ts-json-schema-generator": "2.4.0",
     "typescript": "^5.9.3"
   },

package/scripts/postinstall.js

@@ -1,176 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Post-install script to download the platform-specific arashi binary from GitHub releases
- * This keeps the npm package size small while providing pre-compiled binaries
- */
-
-import { access, constants, mkdir, readFile, rm } from "node:fs/promises";
-import { chmodSync, createWriteStream } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { get } from "node:https";
-import { spawnSync } from "node:child_process";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const PACKAGE_NAME = "arashi";
-const GITHUB_REPO = "corwinm/arashi";
-
-// Determine platform and binary name
-function getPlatformInfo() {
-  const { platform } = process;
-  const { arch } = process;
-
-  let binaryName = "";
-  if (platform === "darwin" && arch === "arm64") {
-    binaryName = `${PACKAGE_NAME}-macos-arm64`;
-  } else if (platform === "linux" && arch === "x64") {
-    binaryName = `${PACKAGE_NAME}-linux-x64`;
-  } else if (platform === "win32" && arch === "x64") {
-    binaryName = `${PACKAGE_NAME}-windows-x64.exe`;
-  } else {
-    throw new Error(
-      `Unsupported platform: ${platform}-${arch}. Please build from source or file an issue at https://github.com/${GITHUB_REPO}/issues`,
-    );
-  }
-
-  return { binaryName, isWindows: platform === "win32" };
-}
-
-// Download file from URL
-function downloadFile(url, dest) {
-  return new Promise((resolve, reject) => {
-    console.log(`Downloading ${url}...`);
-
-    const file = createWriteStream(dest);
-    const request = get(url, (response) => {
-      // Handle redirects
-      if (
-        response.statusCode === 301 ||
-        response.statusCode === 302 ||
-        response.statusCode === 307
-      ) {
-        file.close();
-        downloadFile(response.headers.location, dest).then(resolve).catch(reject);
-        return;
-      }
-
-      if (response.statusCode !== 200) {
-        file.close();
-        reject(new Error(`Failed to download: ${response.statusCode} ${response.statusMessage}`));
-        return;
-      }
-
-      response.pipe(file);
-
-      file.on("finish", () => {
-        file.close(resolve);
-      });
-    });
-
-    request.on("error", (err) => {
-      file.close();
-      reject(err);
-    });
-
-    file.on("error", (err) => {
-      file.close();
-      reject(err);
-    });
-  });
-}
-
-function verifyBinary(binaryPath) {
-  const result = spawnSync(binaryPath, ["--version"], {
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "pipe"],
-  });
-
-  if (result.error) {
-    throw result.error;
-  }
-
-  if (result.status !== 0) {
-    const signalDetail = result.signal ? ` (signal: ${result.signal})` : "";
-    const output = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
-    throw new Error(
-      `Downloaded binary failed smoke test with exit code ${result.status ?? "unknown"}${signalDetail}${output ? `: ${output}` : ""}`,
-    );
-  }
-
-  const versionOutput = (result.stdout ?? "").trim();
-  if (!versionOutput) {
-    throw new Error("Downloaded binary returned success but produced no version output");
-  }
-
-  console.log(`✓ Verified ${PACKAGE_NAME} executable (${versionOutput})`);
-}
-
-// Main installation logic
-async function install() {
-  let binaryPath = "";
-
-  try {
-    // Skip postinstall in development (when installing from the repo)
-    // Check if we're in development by looking for src/ directory
-    const srcDir = join(__dirname, "..", "src");
-    try {
-      await access(srcDir, constants.F_OK);
-      console.log("✓ Development environment detected, skipping binary download");
-      console.log("  Run 'bun run build' to build binary locally");
-      return;
-    } catch {
-      // Not in development, continue with download
-    }
-
-    // Get version from package.json
-    const packageJsonPath = join(__dirname, "..", "package.json");
-    const packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
-    const { version } = packageJson;
-
-    const { binaryName, isWindows } = getPlatformInfo();
-    const binDir = join(__dirname, "..", "bin");
-    binaryPath = join(binDir, binaryName);
-
-    // Check if binary already exists
-    try {
-      await access(binaryPath, constants.F_OK);
-      console.log(`✓ Binary already exists at ${binaryPath}`);
-      return;
-    } catch {
-      // Binary doesn't exist, continue with download
-    }
-
-    // Ensure bin directory exists
-    await mkdir(binDir, { recursive: true });
-
-    // Download binary from GitHub releases
-    const downloadUrl = `https://github.com/${GITHUB_REPO}/releases/download/v${version}/${binaryName}`;
-
-    await downloadFile(downloadUrl, binaryPath);
-
-    // Make binary executable (Unix-like systems)
-    if (!isWindows) {
-      chmodSync(binaryPath, 0o755);
-    }
-
-    verifyBinary(binaryPath);
-
-    console.log(`✓ Successfully installed ${PACKAGE_NAME} v${version}`);
-    console.log(`  Binary location: ${binaryPath}`);
-  } catch (error) {
-    if (binaryPath) {
-      await rm(binaryPath, { force: true }).catch(() => {});
-    }
-
-    console.error(`✗ Failed to install ${PACKAGE_NAME}:`, error.message);
-    console.error(
-      `\nYou can manually download binaries from: https://github.com/${GITHUB_REPO}/releases`,
-    );
-    process.exit(1);
-  }
-}
-
-await install();