@yuanchuan/aivo 0.14.0 → 0.14.2

package/README.md

@@ -9,17 +9,18 @@ npm install -g @yuanchuan/aivo
 ```
 
 This package downloads the matching prebuilt binary for your platform during install.
+If `aivo` is not recognized right away on Windows, open a new terminal and try again.
 
 ## Update
 
 ```bash
-npm install -g @yuanchuan/aivo@latest
+aivo update
 ```
 
-Or:
+If the npm-managed install needs repair, run:
 
 ```bash
-npm update -g @yuanchuan/aivo
+npm install -g @yuanchuan/aivo@latest
 ```
 
 ## Usage

package/bin/aivo.js

@@ -1,31 +1,40 @@
 #!/usr/bin/env node
 
 const { spawn } = require("node:child_process");
-const fs = require("node:fs");
-const { getInstalledBinaryPath } = require("../lib/paths");
+const os = require("node:os");
+const { getInstalledBinaryPath, getPackageRoot } = require("../lib/paths");
+const { formatLaunchError } = require("../lib/launcher");
+const { shouldDelegateWindowsNpmUpdate, spawnWindowsNpmUpdate } = require("../lib/update");
 
-const binaryPath = getInstalledBinaryPath();
+const args = process.argv.slice(2);
 
-if (!fs.existsSync(binaryPath)) {
-  console.error("aivo binary is not installed.");
-  console.error("Reinstall with: npm install -g @yuanchuan/aivo");
-  process.exit(1);
-}
-
-const child = spawn(binaryPath, process.argv.slice(2), {
-  stdio: "inherit"
-});
+function forwardExit(child) {
+  child.on("exit", (code, signal) => {
+    if (signal) {
+      process.exitCode = 128 + (os.constants.signals[signal] || 1);
+      return;
+    }
 
-child.on("exit", (code, signal) => {
-  if (signal) {
-    process.kill(process.pid, signal);
-    return;
-  }
+    process.exit(code ?? 1);
+  });
+}
 
-  process.exit(code ?? 1);
-});
+if (shouldDelegateWindowsNpmUpdate(args, { packageRoot: getPackageRoot() })) {
+  const child = spawnWindowsNpmUpdate(spawn);
+  forwardExit(child);
+  child.on("error", (error) => {
+    console.error(`Failed to launch npm.cmd for update: ${error.message}`);
+    process.exit(1);
+  });
+} else {
+  const binaryPath = getInstalledBinaryPath();
+  const child = spawn(binaryPath, args, {
+    stdio: "inherit"
+  });
 
-child.on("error", (error) => {
-  console.error(`Failed to launch aivo: ${error.message}`);
-  process.exit(1);
-});
+  forwardExit(child);
+  child.on("error", (error) => {
+    console.error(formatLaunchError(error, binaryPath));
+    process.exit(1);
+  });
+}

package/lib/launcher.js

@@ -0,0 +1,27 @@
+"use strict";
+
+const REPAIR_COMMAND = "npm install -g @yuanchuan/aivo@latest";
+
+function formatLaunchError(error, binaryPath, platform = process.platform) {
+  const lines = [
+    `aivo binary is not available at ${binaryPath}.`,
+    "This usually means the npm postinstall download did not complete.",
+    "If you installed with --ignore-scripts, reinstall without it.",
+    `Repair with: ${REPAIR_COMMAND}`
+  ];
+
+  if (error && error.code) {
+    lines.push(`Launch error: ${error.code}`);
+  }
+
+  if (platform === "win32") {
+    lines.push("If you just installed aivo, open a new terminal and try again.");
+  }
+
+  return lines.join("\n");
+}
+
+module.exports = {
+  REPAIR_COMMAND,
+  formatLaunchError
+};

package/lib/update.js

@@ -0,0 +1,54 @@
+"use strict";
+
+const WINDOWS_NPM_UPDATE_COMMAND = "npm.cmd install -g @yuanchuan/aivo@latest";
+
+function normalizePathForMatch(value) {
+  return String(value || "")
+    .replace(/\\/g, "/")
+    .replace(/^\/\/\?\//, "")
+    .toLowerCase();
+}
+
+function isNpmManagedPackageRoot(packageRoot) {
+  const normalized = normalizePathForMatch(packageRoot);
+  return normalized.includes("/node_modules/@yuanchuan/aivo");
+}
+
+function shouldDelegateWindowsNpmUpdate(argv, options = {}) {
+  const platform = options.platform || process.platform;
+  const packageRoot = options.packageRoot;
+
+  if (platform !== "win32") {
+    return false;
+  }
+
+  if (!isNpmManagedPackageRoot(packageRoot)) {
+    return false;
+  }
+
+  if (!Array.isArray(argv) || argv[0] !== "update") {
+    return false;
+  }
+
+  const rest = argv.slice(1);
+  if (rest.length === 0) {
+    return true;
+  }
+
+  return rest.every((arg) => arg === "--no-color");
+}
+
+function spawnWindowsNpmUpdate(spawnImpl, options = {}) {
+  const comspec = options.comspec || process.env.ComSpec || process.env.COMSPEC || "cmd.exe";
+  return spawnImpl(comspec, ["/d", "/s", "/c", WINDOWS_NPM_UPDATE_COMMAND], {
+    stdio: "inherit"
+  });
+}
+
+module.exports = {
+  WINDOWS_NPM_UPDATE_COMMAND,
+  isNpmManagedPackageRoot,
+  normalizePathForMatch,
+  shouldDelegateWindowsNpmUpdate,
+  spawnWindowsNpmUpdate
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yuanchuan/aivo",
-  "version": "0.14.0",
+  "version": "0.14.2",
   "description": "npm wrapper for the aivo CLI",
   "license": "MIT",
   "repository": {

package/scripts/postinstall.js

@@ -10,56 +10,116 @@ const { resolvePlatformAsset } = require("../lib/platform");
 
 const pkg = require(path.join(getPackageRoot(), "package.json"));
 
-async function main() {
-  if (process.env.AIVO_SKIP_POSTINSTALL === "1") {
+const MAX_REDIRECTS = 5;
+const REPAIR_COMMAND = "npm install -g @yuanchuan/aivo@latest";
+
+async function main(options = {}) {
+  const platform = options.platform || process.platform;
+  const arch = options.arch || process.arch;
+  const env = options.env || process.env;
+  const fsImpl = options.fsImpl || fs;
+  const logger = options.logger || console;
+
+  if (env.AIVO_SKIP_POSTINSTALL === "1") {
     return;
   }
 
-  const { assetName } = resolvePlatformAsset();
+  const { assetName } = resolvePlatformAsset(platform, arch);
   const version = pkg.version;
-  const baseUrl =
-    process.env.AIVO_INSTALL_BASE_URL ||
-    `https://github.com/yuanchuan/aivo/releases/download/v${version}`;
+  const baseUrl = env.AIVO_INSTALL_BASE_URL || getReleaseBaseUrl(version);
   const checksumUrl = `${baseUrl}/${assetName}.sha256`;
   const binaryUrl = `${baseUrl}/${assetName}`;
 
-  const checksumText = await downloadText(checksumUrl);
-  const expectedSha = parseChecksumText(checksumText, assetName);
+  const [checksumText, binary] = await Promise.all([
+    downloadText(checksumUrl),
+    downloadBuffer(binaryUrl)
+  ]);
 
+  const expectedSha = parseChecksumText(checksumText, assetName);
   if (!expectedSha) {
     throw new Error(`Checksum asset for ${assetName} could not be parsed.`);
   }
 
-  const binary = await downloadBuffer(binaryUrl);
   const actualSha = sha256(binary);
   if (actualSha !== expectedSha) {
     throw new Error(`Checksum verification failed for ${assetName}.`);
   }
 
   const nativeDir = getNativeDir();
-  const binaryPath = getInstalledBinaryPath();
-  fs.mkdirSync(nativeDir, { recursive: true });
-  fs.writeFileSync(binaryPath, binary);
+  const binaryPath = getInstalledBinaryPath(platform, arch);
+  installBinary({
+    binary,
+    binaryPath,
+    nativeDir,
+    platform,
+    fsImpl
+  });
 
-  if (process.platform !== "win32") {
-    fs.chmodSync(binaryPath, 0o755);
+  logger.log(`Installed aivo ${version} (${assetName})`);
+  if (platform === "win32") {
+    logger.log("If `aivo` is not recognized yet, open a new terminal and try again.");
   }
-
-  console.log(`Installed aivo ${version} (${assetName})`);
 }
 
 function downloadText(url) {
   return downloadBuffer(url).then((buffer) => buffer.toString("utf8"));
 }
 
+function getReleaseBaseUrl(version) {
+  return `https://github.com/yuanchuan/aivo/releases/download/v${version}`;
+}
+
+function installBinary({ binary, binaryPath, nativeDir, platform, fsImpl = fs }) {
+  const tempPath = path.join(
+    nativeDir,
+    `${path.basename(binaryPath)}.tmp-${process.pid}-${Date.now()}`
+  );
+
+  fsImpl.mkdirSync(nativeDir, { recursive: true });
+
+  try {
+    fsImpl.writeFileSync(tempPath, binary);
+    if (platform !== "win32") {
+      fsImpl.chmodSync(tempPath, 0o755);
+    }
+    fsImpl.renameSync(tempPath, binaryPath);
+  } catch (error) {
+    cleanupTempFile(fsImpl, tempPath);
+    throw new Error(`Failed to install ${path.basename(binaryPath)}: ${error.message}`);
+  }
+}
+
+function cleanupTempFile(fsImpl, tempPath) {
+  if (typeof fsImpl.rmSync === "function") {
+    fsImpl.rmSync(tempPath, { force: true });
+    return;
+  }
+
+  try {
+    fsImpl.unlinkSync(tempPath);
+  } catch {
+    // ignore cleanup failures
+  }
+}
+
+function formatInstallError(error, platform = process.platform) {
+  const lines = [error.message, `Repair with: ${REPAIR_COMMAND}`];
+  if (platform === "win32") {
+    lines.push("If you just installed aivo, open a new terminal and try again.");
+  }
+  return lines.join("\n");
+}
+
 function downloadBuffer(url, redirectCount = 0) {
   return new Promise((resolve, reject) => {
-    const request = https.get(
+    const proto = url.startsWith("https://") ? https : require("node:http");
+    const request = proto.get(
       url,
       {
         headers: {
           "User-Agent": "@yuanchuan/aivo-installer"
-        }
+        },
+        timeout: 30_000
       },
       (response) => {
         const status = response.statusCode || 0;
@@ -68,10 +128,15 @@ function downloadBuffer(url, redirectCount = 0) {
           status >= 300 &&
           status < 400 &&
           response.headers.location &&
-          redirectCount < 5
+          redirectCount < MAX_REDIRECTS
         ) {
           response.resume();
-          resolve(downloadBuffer(response.headers.location, redirectCount + 1));
+          const location = response.headers.location;
+          if (!location.startsWith("https://") && !location.startsWith("http://")) {
+            reject(new Error(`Invalid redirect URL: ${location}`));
+            return;
+          }
+          resolve(downloadBuffer(location, redirectCount + 1));
           return;
         }
 
@@ -87,11 +152,27 @@ function downloadBuffer(url, redirectCount = 0) {
       }
     );
 
+    request.on("timeout", () => {
+      request.destroy();
+      reject(new Error(`Download timed out: ${url}`));
+    });
     request.on("error", reject);
   });
 }
 
-main().catch((error) => {
-  console.error(error.message);
-  process.exitCode = 1;
-});
+if (require.main === module) {
+  main().catch((error) => {
+    console.error(formatInstallError(error));
+    process.exitCode = 1;
+  });
+}
+
+module.exports = {
+  REPAIR_COMMAND,
+  downloadBuffer,
+  downloadText,
+  formatInstallError,
+  getReleaseBaseUrl,
+  installBinary,
+  main
+};