@yuanchuan/aivo 0.14.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 yuanchuan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,30 @@
+# @yuanchuan/aivo
+
+npm wrapper for the [`aivo`](https://github.com/yuanchuan/aivo) Rust CLI.
+
+## Install
+
+```bash
+npm install -g @yuanchuan/aivo
+```
+
+This package downloads the matching prebuilt binary for your platform during install.
+
+## Update
+
+```bash
+npm install -g @yuanchuan/aivo@latest
+```
+
+Or:
+
+```bash
+npm update -g @yuanchuan/aivo
+```
+
+## Usage
+
+```bash
+aivo --version
+aivo chat
+```

package/bin/aivo.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+
+const { spawn } = require("node:child_process");
+const fs = require("node:fs");
+const { getInstalledBinaryPath } = require("../lib/paths");
+
+const binaryPath = getInstalledBinaryPath();
+
+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"
+});
+
+child.on("exit", (code, signal) => {
+  if (signal) {
+    process.kill(process.pid, signal);
+    return;
+  }
+
+  process.exit(code ?? 1);
+});
+
+child.on("error", (error) => {
+  console.error(`Failed to launch aivo: ${error.message}`);
+  process.exit(1);
+});

package/lib/checksum.js

@@ -0,0 +1,59 @@
+"use strict";
+
+const { createHash } = require("node:crypto");
+
+function normalizeSha256(value) {
+  const trimmed = value.trim().toLowerCase();
+  if (!/^[a-f0-9]{64}$/.test(trimmed)) {
+    return null;
+  }
+  return trimmed;
+}
+
+function parseChecksumText(text, expectedName) {
+  let fallbackHash = null;
+
+  for (const rawLine of text.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) {
+      continue;
+    }
+
+    const bsdMatch = line.match(/^SHA256 \((.+)\) = ([a-fA-F0-9]{64})$/);
+    if (bsdMatch) {
+      const [, name, hash] = bsdMatch;
+      if (!expectedName || name.endsWith(expectedName)) {
+        return normalizeSha256(hash);
+      }
+      continue;
+    }
+
+    const parts = line.split(/\s+/);
+    const hash = normalizeSha256(parts[0] || "");
+    if (!hash) {
+      continue;
+    }
+
+    const remainder = line.slice(parts[0].length).trim().replace(/^\*\s*/, "");
+    if (!remainder) {
+      fallbackHash = hash;
+      continue;
+    }
+
+    if (remainder === expectedName || remainder.endsWith(`/${expectedName}`)) {
+      return hash;
+    }
+  }
+
+  return fallbackHash;
+}
+
+function sha256(buffer) {
+  return createHash("sha256").update(buffer).digest("hex");
+}
+
+module.exports = {
+  normalizeSha256,
+  parseChecksumText,
+  sha256
+};

package/lib/paths.js

@@ -0,0 +1,23 @@
+"use strict";
+
+const path = require("node:path");
+const { resolvePlatformAsset } = require("./platform");
+
+function getPackageRoot() {
+  return path.resolve(__dirname, "..");
+}
+
+function getNativeDir() {
+  return path.join(getPackageRoot(), "native");
+}
+
+function getInstalledBinaryPath(platform = process.platform, arch = process.arch) {
+  const { binaryName } = resolvePlatformAsset(platform, arch);
+  return path.join(getNativeDir(), binaryName);
+}
+
+module.exports = {
+  getInstalledBinaryPath,
+  getNativeDir,
+  getPackageRoot
+};

package/lib/platform.js

@@ -0,0 +1,37 @@
+"use strict";
+
+const PLATFORM_ASSETS = {
+  darwin: {
+    arm64: "aivo-darwin-arm64",
+    x64: "aivo-darwin-x64"
+  },
+  linux: {
+    arm64: "aivo-linux-arm64",
+    x64: "aivo-linux-x64"
+  },
+  win32: {
+    x64: "aivo-windows-x64.exe"
+  }
+};
+
+function resolvePlatformAsset(platform = process.platform, arch = process.arch) {
+  const platformAssets = PLATFORM_ASSETS[platform];
+  const assetName = platformAssets && platformAssets[arch];
+
+  if (!assetName) {
+    throw new Error(
+      `Unsupported platform: ${platform}-${arch}. ` +
+        "Supported targets: darwin-arm64, darwin-x64, linux-arm64, linux-x64, win32-x64."
+    );
+  }
+
+  return {
+    assetName,
+    binaryName: platform === "win32" ? "aivo.exe" : "aivo"
+  };
+}
+
+module.exports = {
+  PLATFORM_ASSETS,
+  resolvePlatformAsset
+};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@yuanchuan/aivo",
+  "version": "0.14.0",
+  "description": "npm wrapper for the aivo CLI",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yuanchuan/aivo.git",
+    "directory": "npm"
+  },
+  "homepage": "https://github.com/yuanchuan/aivo",
+  "bin": {
+    "aivo": "bin/aivo.js"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "scripts",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js",
+    "test": "node --test"
+  },
+  "keywords": [
+    "aivo",
+    "cli",
+    "ai",
+    "rust"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/scripts/postinstall.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const https = require("node:https");
+const { parseChecksumText, sha256 } = require("../lib/checksum");
+const { getInstalledBinaryPath, getNativeDir, getPackageRoot } = require("../lib/paths");
+const { resolvePlatformAsset } = require("../lib/platform");
+
+const pkg = require(path.join(getPackageRoot(), "package.json"));
+
+async function main() {
+  if (process.env.AIVO_SKIP_POSTINSTALL === "1") {
+    return;
+  }
+
+  const { assetName } = resolvePlatformAsset();
+  const version = pkg.version;
+  const baseUrl =
+    process.env.AIVO_INSTALL_BASE_URL ||
+    `https://github.com/yuanchuan/aivo/releases/download/v${version}`;
+  const checksumUrl = `${baseUrl}/${assetName}.sha256`;
+  const binaryUrl = `${baseUrl}/${assetName}`;
+
+  const checksumText = await downloadText(checksumUrl);
+  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);
+
+  if (process.platform !== "win32") {
+    fs.chmodSync(binaryPath, 0o755);
+  }
+
+  console.log(`Installed aivo ${version} (${assetName})`);
+}
+
+function downloadText(url) {
+  return downloadBuffer(url).then((buffer) => buffer.toString("utf8"));
+}
+
+function downloadBuffer(url, redirectCount = 0) {
+  return new Promise((resolve, reject) => {
+    const request = https.get(
+      url,
+      {
+        headers: {
+          "User-Agent": "@yuanchuan/aivo-installer"
+        }
+      },
+      (response) => {
+        const status = response.statusCode || 0;
+
+        if (
+          status >= 300 &&
+          status < 400 &&
+          response.headers.location &&
+          redirectCount < 5
+        ) {
+          response.resume();
+          resolve(downloadBuffer(response.headers.location, redirectCount + 1));
+          return;
+        }
+
+        if (status < 200 || status >= 300) {
+          reject(new Error(`Download failed: ${status} ${url}`));
+          response.resume();
+          return;
+        }
+
+        const chunks = [];
+        response.on("data", (chunk) => chunks.push(chunk));
+        response.on("end", () => resolve(Buffer.concat(chunks)));
+      }
+    );
+
+    request.on("error", reject);
+  });
+}
+
+main().catch((error) => {
+  console.error(error.message);
+  process.exitCode = 1;
+});