arashi 1.11.3 → 1.13.0

package/README.md

@@ -47,13 +47,31 @@ 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
+```
+
+To check for package updates or refresh the matching platform binary, run:
+
+```bash
+arashi update --check
+arashi update --dry-run
+arashi update --yes
+```
+
+`arashi update` can update npm-managed installs when it can confidently detect the package manager, including npm, pnpm, Yarn, Bun, and Vite+ (`vp update -g arashi`). For official curl installer installs, `arashi update --yes` reruns the installer against the current binary directory.
+
 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 +112,8 @@ bun run build
 Arashi currently provides these commands:
 
 - `arashi init`
+- `arashi install`
+- `arashi update [--check] [--dry-run] [--yes]`
 - `arashi add <git-url>`
 - `arashi clone [--all]`
 - `arashi create <branch>`

package/bin/arashi.js

@@ -1,110 +1,158 @@
 #!/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";
+import { runNpmManagedUpdate } from "./update.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;
+  }
+}
+
+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" };
   }
 
-  console.log("arashi binary missing; running postinstall to download.");
-  const result = spawnSync(process.execPath, [postinstallPath], { stdio: "inherit" });
+  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";
+}
+
+export function isExplicitUpdateCommand(argv) {
+  return argv[0] === "update";
+}
+
+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;
+    }
 
-  if (result.error) {
-    console.error(`Failed to run postinstall. ${result.error.message}.`);
-    process.exit(1);
-  }
+    if (isExplicitUpdateCommand(argv)) {
+      return runNpmManagedUpdate(argv.slice(1), options);
+    }
 
-  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);
+    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 (!options.force && (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/bin/update.js

@@ -0,0 +1,323 @@
+import { spawnSync } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { fileURLToPath } from "node:url";
+import { getPlatformInfo, installBinary, MANUAL_INSTALL_URL, PACKAGE_NAME } from "./install-binary.js";
+
+export const UPDATE_COMMAND_DESCRIPTION = "Check for and apply Arashi updates";
+
+export function parseUpdateArgs(argv = []) {
+  return {
+    check: argv.includes("--check"),
+    dryRun: argv.includes("--dry-run"),
+    yes: argv.includes("--yes") || argv.includes("-y"),
+  };
+}
+
+function normalizeVersion(version) {
+  return String(version ?? "").trim().replace(/^v/, "").split("+")[0];
+}
+
+export function compareVersions(a, b) {
+  const left = normalizeVersion(a).split(/[.-]/);
+  const right = normalizeVersion(b).split(/[.-]/);
+  const length = Math.max(left.length, right.length);
+
+  for (let index = 0; index < length; index += 1) {
+    const leftPart = left[index] ?? "0";
+    const rightPart = right[index] ?? "0";
+    const leftNumber = Number(leftPart);
+    const rightNumber = Number(rightPart);
+
+    if (Number.isInteger(leftNumber) && Number.isInteger(rightNumber)) {
+      if (leftNumber > rightNumber) return 1;
+      if (leftNumber < rightNumber) return -1;
+      continue;
+    }
+
+    if (leftPart === rightPart) continue;
+    if (leftPart === "") return 1;
+    if (rightPart === "") return -1;
+    return leftPart > rightPart ? 1 : -1;
+  }
+
+  return 0;
+}
+
+export async function readPackageMetadata(rootDir, { readFileImpl = readFile } = {}) {
+  const packageJsonPath = join(rootDir, "package.json");
+  const packageJson = JSON.parse(await readFileImpl(packageJsonPath, "utf8"));
+  return { name: packageJson.name, packageJsonPath, version: packageJson.version };
+}
+
+export function detectNpmManagedInstall({ rootDir, metadata } = {}) {
+  if (!rootDir || metadata?.name !== PACKAGE_NAME || !metadata?.version) {
+    return { method: "ambiguous" };
+  }
+
+  return { method: "npm-managed", rootDir, version: metadata.version };
+}
+
+export async function fetchLatestPackageVersion({ fetchImpl = fetch, packageName = PACKAGE_NAME } = {}) {
+  const response = await fetchImpl(`https://registry.npmjs.org/${packageName}/latest`, {
+    headers: { accept: "application/json" },
+  });
+
+  if (!response.ok) {
+    throw new Error(`npm registry returned ${response.status} ${response.statusText}`.trim());
+  }
+
+  const metadata = await response.json();
+  if (!metadata.version) {
+    throw new Error("npm registry response did not include a version");
+  }
+
+  return metadata.version;
+}
+
+export async function fetchLatestGitHubRelease({ fetchImpl = fetch, repo = "corwinm/arashi" } = {}) {
+  const response = await fetchImpl(`https://api.github.com/repos/${repo}/releases/latest`, {
+    headers: { accept: "application/vnd.github+json" },
+  });
+
+  if (!response.ok) {
+    throw new Error(`GitHub releases returned ${response.status} ${response.statusText}`.trim());
+  }
+
+  const release = await response.json();
+  const version = normalizeVersion(release.tag_name ?? release.name);
+  if (!version) {
+    throw new Error("GitHub release response did not include a tag");
+  }
+
+  return {
+    htmlUrl: release.html_url ?? MANUAL_INSTALL_URL,
+    version,
+  };
+}
+
+export function selectPackageManagerCommand({ env = process.env, rootDir } = {}) {
+  const userAgent = env.npm_config_user_agent ?? "";
+  const execPath = env.npm_execpath ?? "";
+  const combined = `${userAgent} ${execPath}`.toLowerCase();
+  const normalizedRootDir = String(rootDir ?? "").toLowerCase();
+  const looksLikeVitePlus =
+    combined.includes("vite-plus") ||
+    /(^|[\\/\s])vp(?:\.exe)?($|[\\/\s])/.test(combined) ||
+    /(^|[\\/])\.vite-plus([\\/]|$)/.test(normalizedRootDir);
+
+  if (looksLikeVitePlus) {
+    return { args: ["update", "-g", PACKAGE_NAME], command: "vp", label: "Vite+" };
+  }
+
+  if (combined.includes("pnpm")) {
+    return { args: ["add", "-g", `${PACKAGE_NAME}@latest`], command: "pnpm", label: "pnpm" };
+  }
+
+  if (combined.includes("yarn")) {
+    return { args: ["global", "add", `${PACKAGE_NAME}@latest`], command: "yarn", label: "yarn" };
+  }
+
+  if (combined.includes("bun")) {
+    return { args: ["add", "-g", `${PACKAGE_NAME}@latest`], command: "bun", label: "bun" };
+  }
+
+  if (combined.includes("npm")) {
+    return { args: ["install", "-g", `${PACKAGE_NAME}@latest`], command: "npm", label: "npm" };
+  }
+
+  return null;
+}
+
+export function formatManualUpdateGuidance(latestVersion, platformInfo) {
+  const lines = [
+    "Automatic update is not available for this install method.",
+    `Latest release: v${latestVersion}`,
+    `Manual releases: ${MANUAL_INSTALL_URL}`,
+  ];
+
+  if (platformInfo?.binaryName) {
+    lines.push(`Download asset for this platform: ${platformInfo.binaryName}`);
+  }
+
+  lines.push("Replace the existing arashi binary with the downloaded asset and make it executable if needed.");
+  return lines.join("\n");
+}
+
+export function formatSupportedPackageManagerGuidance() {
+  return [
+    "Could not confidently detect the package manager used for this npm-managed install.",
+    "Run one of these manually if it matches how you installed Arashi:",
+    `  npm install -g ${PACKAGE_NAME}@latest`,
+    `  pnpm add -g ${PACKAGE_NAME}@latest`,
+    `  yarn global add ${PACKAGE_NAME}@latest`,
+    `  bun add -g ${PACKAGE_NAME}@latest`,
+    `  vp update -g ${PACKAGE_NAME}`,
+  ].join("\n");
+}
+
+export async function defaultConfirmPrompt(message) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await rl.question(message);
+    return /^(y|yes)$/i.test(answer.trim());
+  } finally {
+    rl.close();
+  }
+}
+
+async function confirmUpdate({ promptImpl = defaultConfirmPrompt, yes }) {
+  if (yes) return true;
+  if (!process.stdin.isTTY) return false;
+  return promptImpl("Update Arashi now? [y/N] ");
+}
+
+function defaultRootDir(binDir) {
+  return join(binDir ?? fileURLToPath(new URL(".", import.meta.url)), "..");
+}
+
+export async function runNpmManagedUpdate(argv = [], options = {}) {
+  const flags = parseUpdateArgs(argv);
+  const log = options.log ?? console.log;
+  const errorLog = options.error ?? console.error;
+  const rootDir = options.rootDir ?? defaultRootDir(options.binDir);
+  let metadata;
+
+  try {
+    metadata = options.metadata ?? (await readPackageMetadata(rootDir, options));
+  } catch (error) {
+    errorLog(`Failed to read package metadata: ${error instanceof Error ? error.message : String(error)}`);
+    errorLog(formatSupportedPackageManagerGuidance());
+    return 1;
+  }
+
+  const install = detectNpmManagedInstall({ metadata, rootDir });
+  if (install.method !== "npm-managed") {
+    log(formatSupportedPackageManagerGuidance());
+    return 0;
+  }
+
+  let latestVersion;
+  try {
+    latestVersion = options.latestVersion ?? (await fetchLatestPackageVersion(options));
+  } catch (error) {
+    errorLog(`Failed to check latest ${PACKAGE_NAME} version: ${error instanceof Error ? error.message : String(error)}`);
+    errorLog(`Manual releases: ${MANUAL_INSTALL_URL}`);
+    return 1;
+  }
+
+  if (compareVersions(metadata.version, latestVersion) >= 0) {
+    log(`${PACKAGE_NAME} is already up to date (v${metadata.version}).`);
+    return 0;
+  }
+
+  const packageManager = options.packageManager ?? selectPackageManagerCommand(options);
+  log(`Update available: ${PACKAGE_NAME} v${metadata.version} -> v${latestVersion}`);
+
+  if (flags.check) {
+    log("Check only: no changes made.");
+    return 0;
+  }
+
+  if (!packageManager) {
+    log(formatSupportedPackageManagerGuidance());
+    return 0;
+  }
+
+  const renderedCommand = [packageManager.command, ...packageManager.args].join(" ");
+  log(`Selected update command: ${renderedCommand}`);
+  log("Binary refresh: reinstall the matching platform binary after the package update.");
+
+  if (flags.dryRun) {
+    log("Dry run: no changes made.");
+    return 0;
+  }
+
+  if (!(await confirmUpdate({ promptImpl: options.promptImpl, yes: flags.yes }))) {
+    errorLog("Update skipped. Rerun with --yes for non-interactive updates or use --dry-run to inspect the plan.");
+    return 1;
+  }
+
+  const spawnSyncImpl = options.spawnSyncImpl ?? spawnSync;
+  const result = spawnSyncImpl(packageManager.command, packageManager.args, {
+    cwd: rootDir,
+    encoding: "utf8",
+    stdio: "inherit",
+  });
+
+  if (result.error) {
+    errorLog(`Package manager failed to start: ${result.error.message}`);
+    return 1;
+  }
+
+  if (result.status !== 0) {
+    errorLog(`Package manager update failed with exit code ${result.status ?? "unknown"}. Existing binary was not removed.`);
+    return 1;
+  }
+
+  let updatedMetadata = metadata;
+  try {
+    updatedMetadata = await readPackageMetadata(rootDir, options);
+  } catch {
+    updatedMetadata = { ...metadata, version: latestVersion };
+  }
+
+  try {
+    const installBinaryImpl = options.installBinaryImpl ?? installBinary;
+    const installResult = await installBinaryImpl({
+      ...options,
+      binDir: options.binDir,
+      force: true,
+      rootDir,
+      version: updatedMetadata.version,
+    });
+    log(`✓ Updated ${PACKAGE_NAME} from v${metadata.version} to v${updatedMetadata.version}.`);
+    log(`  Package-manager command: ${renderedCommand}`);
+    log(`  Binary location: ${installResult.binaryPath ?? "installed platform binary"}`);
+    return 0;
+  } catch (error) {
+    errorLog(`Package updated, but binary refresh failed: ${error instanceof Error ? error.message : String(error)}`);
+    errorLog("Run `arashi install` to retry the binary installation, or download a release manually.");
+    return 1;
+  }
+}
+
+export async function runDirectBinaryUpdate(argv = [], options = {}) {
+  const flags = parseUpdateArgs(argv);
+  const log = options.log ?? console.log;
+  const errorLog = options.error ?? console.error;
+  const currentVersion = options.currentVersion;
+
+  let release;
+  try {
+    release = options.latestRelease ?? (await fetchLatestGitHubRelease(options));
+  } catch (error) {
+    errorLog(`Failed to check latest ${PACKAGE_NAME} release: ${error instanceof Error ? error.message : String(error)}`);
+    errorLog(`Manual releases: ${MANUAL_INSTALL_URL}`);
+    return 1;
+  }
+
+  let platformInfo;
+  try {
+    platformInfo = getPlatformInfo({ arch: options.arch, platform: options.platform });
+  } catch {
+    platformInfo = undefined;
+  }
+
+  if (currentVersion && compareVersions(currentVersion, release.version) >= 0) {
+    log(`${PACKAGE_NAME} direct binary is already current (v${currentVersion}).`);
+    return 0;
+  }
+
+  if (currentVersion) {
+    log(`Update available: ${PACKAGE_NAME} v${currentVersion} -> v${release.version}`);
+  } else {
+    log(`Latest ${PACKAGE_NAME} release: v${release.version}`);
+  }
+  log(formatManualUpdateGuidance(release.version, platformInfo));
+  if (release.htmlUrl) log(`Release URL: ${release.htmlUrl}`);
+  if (flags.check) log("Check only: no changes made.");
+  if (flags.dryRun) log("Dry run: no changes made.");
+  return 0;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arashi",
-  "version": "1.11.3",
+  "version": "1.13.0",
   "description": "Git worktree manager for meta-repositories - The eye of the storm for your development workflow",
   "keywords": [
     "cli",
@@ -29,9 +29,10 @@
   "files": [
     "bin/arashi",
     "bin/arashi.js",
+    "bin/install-binary.js",
+    "bin/update.js",
     "bin/arashi.bat",
     "bin/arashi.ps1",
-    "scripts/postinstall.js",
     "schema/config.schema.json",
     "README.md",
     "LICENSE"
@@ -65,7 +66,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"
   },

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();