@ariacompute/engine-ts 1.14.0 → 1.15.0

package/README.md

@@ -1,10 +1,11 @@
 # @ariacompute/engine-ts
 
 ```bash
-export ARIA_FFI_LIB=/path/to/libaria_ffi.so
 npm i @ariacompute/engine-ts
 ```
 
+`libaria_ffi` is resolved as `ARIA_FFI_LIB` → package-bundled `dist/lib/` → `~/.ariacompute/lib/` (same as `aria-engine upgrade`). If none exist, `Engine.open` downloads the latest stable `libaria_ffi_{ver}_{os}.tar.gz` from regional Releases. `ARIA_FFI_LIB` remains an optional override.
+
 ```ts
 import { Engine } from "@ariacompute/engine-ts";
 const eng = new Engine("/path/to/bundle");

package/dist/index.d.ts

@@ -53,6 +53,13 @@ export declare function hubFileUrls(source: "huggingface" | "modelscope", model:
  * Matches aria-engine download: .com → Hugging Face, .cn → ModelScope.
  * Dashboard is not used. Skips the download when a valid bundle is already cached. */
 export declare function downloadModel(model: string, tokenOrOpts?: string | OpenOptions, site?: string): Promise<string>;
+export declare function ffiLibName(platform?: string): string;
+export declare function cachedFfiPath(platform?: string): string | undefined;
+export declare function ffiAssetOs(platform?: string, arch?: string): string;
+export declare function selectLatestStable(releases: Array<Record<string, unknown>>): string;
+export declare function extractFfiArchive(archive: string, destDir: string, want?: string): string;
+/** Return a path to libaria_ffi, downloading the latest stable Release if needed. */
+export declare function ensureFfiLib(site?: string): Promise<string>;
 export declare function isLocalRef(modelRef: string): boolean;
 export declare class Engine {
     private lib;

package/dist/index.js

@@ -41,12 +41,20 @@ exports.configYmlScalar = configYmlScalar;
 exports.resolveHubToken = resolveHubToken;
 exports.hubFileUrls = hubFileUrls;
 exports.downloadModel = downloadModel;
+exports.ffiLibName = ffiLibName;
+exports.cachedFfiPath = cachedFfiPath;
+exports.ffiAssetOs = ffiAssetOs;
+exports.selectLatestStable = selectLatestStable;
+exports.extractFfiArchive = extractFfiArchive;
+exports.ensureFfiLib = ensureFfiLib;
 exports.isLocalRef = isLocalRef;
+const node_child_process_1 = require("node:child_process");
 const fs = __importStar(require("node:fs"));
 const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
 const promises_1 = require("node:stream/promises");
 const node_stream_1 = require("node:stream");
+const zlib = __importStar(require("node:zlib"));
 const DEFAULT_SITE = "https://ariacompute.com";
 const DEFAULT_SDK = "v1.0";
 const HUB_REQUIRED = ["config.json", "weight.bin"];
@@ -282,10 +290,217 @@ async function downloadModel(model, tokenOrOpts, site = DEFAULT_SITE) {
         throw e;
     }
 }
-function loadLib(ffiLib) {
-    const libPath = ffiLib || process.env.ARIA_FFI_LIB;
+const SDK_UA = "aria-engine-sdk/0.1.0";
+function ffiLibName(platform = process.platform) {
+    if (platform === "win32" || platform.toLowerCase().startsWith("win"))
+        return "aria_ffi.dll";
+    if (platform === "darwin")
+        return "libaria_ffi.dylib";
+    return "libaria_ffi.so";
+}
+function libDir() {
+    return path.join(ariaHome(), "lib");
+}
+function cachedFfiPath(platform = process.platform) {
+    const candidate = path.join(libDir(), ffiLibName(platform));
+    return fs.existsSync(candidate) ? candidate : undefined;
+}
+function bundledFfiPath() {
+    const candidate = path.join(__dirname, "lib", ffiLibName());
+    return fs.existsSync(candidate) ? candidate : undefined;
+}
+function ffiAssetOs(platform = process.platform, arch = process.arch) {
+    const p = platform.toLowerCase();
+    const a = arch.toLowerCase();
+    if (p === "linux" && (a === "x64" || a === "x86_64" || a === "amd64"))
+        return "linux_x86_64";
+    if (p === "linux" && (a === "arm64" || a === "aarch64"))
+        return "linux_arm64";
+    if (p === "darwin" || p === "macos")
+        return "macos";
+    if ((p === "win32" || p.startsWith("win")) && (a === "x64" || a === "x86_64" || a === "amd64")) {
+        return "windows_x86_64";
+    }
+    throw new Error(`unsupported platform ${platform}/${arch} for libaria_ffi`);
+}
+function stripV(tag) {
+    const t = tag.trim();
+    return t.startsWith("v") || t.startsWith("V") ? t.slice(1) : t;
+}
+function parseSemver(tag) {
+    const core = stripV(tag).split("-", 1)[0].split("+", 1)[0];
+    const parts = core.split(".");
+    if (!parts.length || !/^\d+$/.test(parts[0]))
+        return undefined;
+    return [
+        Number(parts[0]),
+        parts[1] && /^\d+$/.test(parts[1]) ? Number(parts[1]) : 0,
+        parts[2] && /^\d+$/.test(parts[2]) ? Number(parts[2]) : 0,
+    ];
+}
+function selectLatestStable(releases) {
+    let bestTag;
+    let bestKey = [-1, -1, -1];
+    for (const rel of releases) {
+        if (rel.draft || rel.prerelease)
+            continue;
+        const tag = String(rel.tag_name || rel.tag || "");
+        const parsed = parseSemver(tag);
+        if (!parsed)
+            continue;
+        if (parsed[0] > bestKey[0] ||
+            (parsed[0] === bestKey[0] && parsed[1] > bestKey[1]) ||
+            (parsed[0] === bestKey[0] && parsed[1] === bestKey[1] && parsed[2] > bestKey[2])) {
+            bestKey = parsed;
+            bestTag = tag;
+        }
+    }
+    if (!bestTag)
+        throw new Error("no stable release found for libaria_ffi");
+    return stripV(bestTag);
+}
+function upgradeOrg(site) {
+    const cfg = configYmlScalar("upgrade_url");
+    if (cfg)
+        return cfg.replace(/\/$/, "");
+    const hint = (site || configYmlScalar("site_url") || DEFAULT_SITE).toLowerCase();
+    if (hint.includes("ariacompute.cn") || hint.includes("gitee.com")) {
+        return "https://gitee.com/ariacompute";
+    }
+    return "https://github.com/ariacompute";
+}
+function releasesApiUrl(org) {
+    const owner = org.replace(/\/$/, "").split("/").pop() || "ariacompute";
+    if (org.toLowerCase().includes("gitee.com")) {
+        return `https://gitee.com/api/v5/repos/${owner}/engine/releases?per_page=30`;
+    }
+    return `https://api.github.com/repos/${owner}/engine/releases?per_page=30`;
+}
+function extractFfiArchive(archive, destDir, want = ffiLibName()) {
+    const tar = zlib.gunzipSync(fs.readFileSync(archive));
+    let offset = 0;
+    while (offset + 512 <= tar.length) {
+        const header = tar.subarray(offset, offset + 512);
+        if (header.every((b) => b === 0))
+            break;
+        const name = header.subarray(0, 100).toString("utf8").replace(/\0.*$/, "");
+        const sizeOctal = header.subarray(124, 136).toString("utf8").replace(/\0/g, "").trim();
+        const size = Number.parseInt(sizeOctal, 8) || 0;
+        const typeFlag = header[156];
+        offset += 512;
+        const isFile = typeFlag === 0 || typeFlag === 48; // '\0' or '0'
+        if (isFile && path.basename(name) === want) {
+            fs.mkdirSync(destDir, { recursive: true });
+            const dest = path.join(destDir, want);
+            fs.writeFileSync(dest, tar.subarray(offset, offset + size));
+            try {
+                fs.chmodSync(dest, 0o755);
+            }
+            catch {
+                /* windows */
+            }
+            return dest;
+        }
+        offset += Math.ceil(size / 512) * 512;
+    }
+    throw new Error(`${want} not found in ${archive}`);
+}
+function httpGetBytesSync(url) {
+    const script = 'fetch(process.env.ARIA_FFI_URL,{headers:{"User-Agent":"aria-engine-sdk/0.1.0"},redirect:"follow"}).then(async r=>{if(!r.ok){process.stderr.write("HTTP "+r.status);process.exit(1)}process.stdout.write(Buffer.from(await r.arrayBuffer()))}).catch(e=>{process.stderr.write(String(e&&e.message||e));process.exit(1)})';
+    const r = (0, node_child_process_1.spawnSync)(process.execPath, ["-e", script], {
+        env: { ...process.env, ARIA_FFI_URL: url },
+        encoding: "buffer",
+        maxBuffer: 256 * 1024 * 1024,
+    });
+    if (r.status !== 0) {
+        throw new Error(`download failed: ${(r.stderr && r.stderr.toString()) || "exit " + r.status}`);
+    }
+    return r.stdout;
+}
+async function httpGetBytes(url) {
+    const resp = await fetch(url, { headers: { "User-Agent": SDK_UA }, redirect: "follow" });
+    if (!resp.ok)
+        throw new Error(`HTTP ${resp.status} ${url}`);
+    return Buffer.from(await resp.arrayBuffer());
+}
+function installFfiFromReleases(raw, archiveBytes) {
+    let releases;
+    try {
+        releases = JSON.parse(raw.toString("utf8"));
+    }
+    catch {
+        throw new Error("invalid releases JSON");
+    }
+    if (!Array.isArray(releases))
+        throw new Error("unexpected releases payload");
+    const ver = selectLatestStable(releases);
+    const assetName = `libaria_ffi_${ver}_${ffiAssetOs()}.tar.gz`;
+    let url;
+    for (const rel of releases) {
+        const tag = String(rel.tag_name || rel.tag || "");
+        if (stripV(tag) !== ver)
+            continue;
+        const assets = rel.assets || [];
+        for (const asset of assets) {
+            if (asset.name === assetName) {
+                url = asset.browser_download_url || asset.direct_asset_url;
+                break;
+            }
+        }
+        if (url)
+            break;
+    }
+    if (!url)
+        throw new Error(`release asset not found: ${assetName}`);
+    const staging = path.join(ariaHome(), "tmp", `ffi-${ver}`);
+    fs.rmSync(staging, { recursive: true, force: true });
+    fs.mkdirSync(staging, { recursive: true });
+    const archive = path.join(staging, assetName);
+    try {
+        fs.writeFileSync(archive, archiveBytes(url));
+        return extractFfiArchive(archive, libDir(), ffiLibName());
+    }
+    finally {
+        fs.rmSync(staging, { recursive: true, force: true });
+    }
+}
+/** Return a path to libaria_ffi, downloading the latest stable Release if needed. */
+async function ensureFfiLib(site) {
+    const env = process.env.ARIA_FFI_LIB;
+    if (env && fs.existsSync(env))
+        return env;
+    const bundled = bundledFfiPath();
+    if (bundled)
+        return bundled;
+    const cached = cachedFfiPath();
+    if (cached)
+        return cached;
+    const org = upgradeOrg(site);
+    const raw = await httpGetBytes(releasesApiUrl(org));
+    return installFfiFromReleases(raw, (assetUrl) => httpGetBytesSync(assetUrl));
+}
+function ensureFfiLibSync(site) {
+    const env = process.env.ARIA_FFI_LIB;
+    if (env && fs.existsSync(env))
+        return env;
+    const bundled = bundledFfiPath();
+    if (bundled)
+        return bundled;
+    const cached = cachedFfiPath();
+    if (cached)
+        return cached;
+    const org = upgradeOrg(site);
+    const raw = httpGetBytesSync(releasesApiUrl(org));
+    return installFfiFromReleases(raw, httpGetBytesSync);
+}
+function loadLib(ffiLib, site) {
+    const libPath = ffiLib ||
+        process.env.ARIA_FFI_LIB ||
+        bundledFfiPath() ||
+        cachedFfiPath() ||
+        ensureFfiLibSync(site);
     if (!libPath)
-        throw new Error("aria FFI lib not found; set ARIA_FFI_LIB or pass ffiLib");
+        throw new Error("Cannot locate libaria_ffi");
     const koffiNS = require("koffi");
     return koffiNS.load(libPath);
 }
@@ -295,7 +510,7 @@ function isLocalRef(modelRef) {
 class Engine {
     /** Construct from a local bundle directory. */
     constructor(bundle, opts = {}) {
-        this.lib = loadLib(opts.ffiLib);
+        this.lib = loadLib(opts.ffiLib, opts.site);
         this.fnInit = this.lib.func("aria_model_init", "void*", ["str"]);
         this.fnDestroy = this.lib.func("aria_model_destroy", "void", ["void*"]);
         this.fnComplete = this.lib.func("aria_complete", "int", ["void*", "str", "str", "str", "void*", "size_t"]);
@@ -311,6 +526,7 @@ class Engine {
     /** Auto-detect: a value containing a separator or already on disk is a local
      * path; otherwise it is a model name downloaded from the regional public hub. */
     static async open(modelRef, opts = {}) {
+        await ensureFfiLib(opts.site);
         if (isLocalRef(modelRef))
             return new Engine(modelRef, opts);
         const bundle = await downloadModel(modelRef, opts);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ariacompute/engine-ts",
-  "version": "1.14.0",
+  "version": "1.15.0",
   "description": "TypeScript/Node SDK for Aria Engine",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",