mafit 1.0.0 → 1.0.1

package/dist/bin/mafit.cjs

@@ -1,22 +1,51 @@
 #!/usr/bin/env node
 const fs = require("node:fs");
+const os = require("node:os");
 const path = require("node:path");
+const http = require("node:http");
+const https = require("node:https");
 const { spawnSync } = require("node:child_process");
 
 const binaryByPlatform = {
-  "linux-x64": "mafit-linux-x64",
-  "darwin-x64": "mafit-darwin-x64",
-  "darwin-arm64": "mafit-darwin-arm64",
-  "win32-x64": "mafit-win32-x64.exe"
+  "linux-x64": {
+    "id": "linux-x64",
+    "platform": "linux",
+    "arch": "x64",
+    "filename": "mafit-linux-x64"
+  },
+  "darwin-x64": {
+    "id": "darwin-x64",
+    "platform": "darwin",
+    "arch": "x64",
+    "filename": "mafit-darwin-x64"
+  },
+  "darwin-arm64": {
+    "id": "darwin-arm64",
+    "platform": "darwin",
+    "arch": "arm64",
+    "filename": "mafit-darwin-arm64"
+  },
+  "win32-x64": {
+    "id": "win32-x64",
+    "platform": "win32",
+    "arch": "x64",
+    "filename": "mafit-win32-x64.exe"
+  }
 };
 const fallbackByPlatform = {
   "win32-arm64": "win32-x64"
 };
+const version = "1.0.1";
+const binaryVersion = "1.0.1-bin.0";
+const defaultUrlTemplate = "https://cdn.jsdelivr.net/npm/mafit@{binaryVersion}/dist/bin/{filename}";
 const key = `${process.platform}-${process.arch}`;
 const resolvedKey = binaryByPlatform[key] ? key : (fallbackByPlatform[key] || "");
-const binaryName = binaryByPlatform[resolvedKey];
+const target = binaryByPlatform[resolvedKey];
+const binaryName = target && target.filename;
+const ensureOnly = process.argv[2] === "--mafit-internal-ensure";
+const cliArgs = ensureOnly ? [] : process.argv.slice(2);
 
-if (!binaryName) {
+if (!target || !binaryName) {
   console.error(`mafit: unsupported platform ${key}`);
   console.error("supported: linux-x64, darwin-x64, darwin-arm64, win32-x64");
   process.exit(1);
@@ -26,29 +55,145 @@ if (resolvedKey && resolvedKey !== key) {
   console.error(`mafit: ${key} fallback to ${resolvedKey}`);
 }
 
-const binaryPath = path.join(__dirname, binaryName);
-if (!fs.existsSync(binaryPath)) {
-  console.error(`mafit: missing binary for ${key}`);
-  console.error(`expected file: ${binaryPath}`);
-  process.exit(1);
-}
+const getCacheRoot = () => {
+  if (process.env.MAFIT_BINARY_CACHE_DIR) {
+    return process.env.MAFIT_BINARY_CACHE_DIR;
+  }
+  if (process.platform === "win32") {
+    const localAppData = process.env.LOCALAPPDATA || path.join(os.homedir(), "AppData", "Local");
+    return path.join(localAppData, "mafit", "bin");
+  }
+  const xdg = process.env.XDG_CACHE_HOME || path.join(os.homedir(), ".cache");
+  return path.join(xdg, "mafit", "bin");
+};
+
+const applyTemplate = (template) =>
+  template
+    .replaceAll("{version}", version)
+    .replaceAll("{binaryVersion}", binaryVersion)
+    .replaceAll("{id}", target.id)
+    .replaceAll("{platform}", target.platform)
+    .replaceAll("{arch}", target.arch)
+    .replaceAll("{filename}", target.filename);
 
-if (process.platform !== "win32") {
+const urlTemplate = process.env.MAFIT_BINARY_URL_TEMPLATE || defaultUrlTemplate;
+const downloadUrl = applyTemplate(urlTemplate);
+const packagedBinaryPath = path.join(__dirname, binaryName);
+const cacheBinaryPath = path.join(getCacheRoot(), version, binaryName);
+
+const ensureExecutable = (filePath) => {
+  if (process.platform === "win32") {
+    return;
+  }
   try {
-    fs.chmodSync(binaryPath, 0o755);
+    fs.chmodSync(filePath, 0o755);
   } catch {}
-}
+};
 
-const result = spawnSync(binaryPath, process.argv.slice(2), { stdio: "inherit" });
+const makeRequest = (urlString, redirectsLeft = 5) =>
+  new Promise((resolve, reject) => {
+    const lib = urlString.startsWith("https://") ? https : http;
+    const req = lib.get(
+      urlString,
+      {
+        headers: {
+          "User-Agent": `mafit/${version}`,
+        },
+      },
+      (res) => {
+        const status = res.statusCode || 0;
+        const location = res.headers.location;
 
-if (result.error) {
-  console.error(`mafit: failed to start binary: ${binaryPath}`);
-  console.error(result.error.message);
-  process.exit(1);
-}
+        if (status >= 300 && status < 400 && location) {
+          if (redirectsLeft <= 0) {
+            res.resume();
+            reject(new Error(`too many redirects: ${urlString}`));
+            return;
+          }
+          const nextUrl = new URL(location, urlString).toString();
+          res.resume();
+          resolve(makeRequest(nextUrl, redirectsLeft - 1));
+          return;
+        }
 
-if (typeof result.status === "number") {
-  process.exit(result.status);
-}
+        if (status !== 200) {
+          res.resume();
+          reject(new Error(`download failed with status ${status}: ${urlString}`));
+          return;
+        }
+
+        resolve(res);
+      }
+    );
+
+    req.on("error", reject);
+    req.setTimeout(30000, () => req.destroy(new Error("download timed out")));
+  });
 
-process.exit(1);
+const downloadBinary = async (targetPath) => {
+  fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+  const tempPath = `${targetPath}.part-${process.pid}`;
+  const stream = fs.createWriteStream(tempPath, { mode: 0o755 });
+  const response = await makeRequest(downloadUrl);
+
+  await new Promise((resolve, reject) => {
+    response.pipe(stream);
+    response.on("error", reject);
+    stream.on("error", reject);
+    stream.on("finish", resolve);
+  });
+
+  fs.renameSync(tempPath, targetPath);
+  ensureExecutable(targetPath);
+};
+
+const resolveBinaryPath = async () => {
+  if (fs.existsSync(packagedBinaryPath)) {
+    ensureExecutable(packagedBinaryPath);
+    return packagedBinaryPath;
+  }
+
+  if (fs.existsSync(cacheBinaryPath)) {
+    ensureExecutable(cacheBinaryPath);
+    return cacheBinaryPath;
+  }
+
+  console.error(`mafit: downloading ${target.id} binary...`);
+  try {
+    await downloadBinary(cacheBinaryPath);
+  } catch (error) {
+    console.error(`mafit: failed to download binary for ${target.id}`);
+    console.error(`url: ${downloadUrl}`);
+    console.error(`set MAFIT_BINARY_URL_TEMPLATE to your mirror if needed`);
+    console.error(error && error.message ? error.message : String(error));
+    process.exit(1);
+  }
+  return cacheBinaryPath;
+};
+
+const run = async () => {
+  const binaryPath = await resolveBinaryPath();
+  if (ensureOnly) {
+    return;
+  }
+
+  const result = spawnSync(binaryPath, cliArgs, { stdio: "inherit" });
+
+  if (result.error) {
+    console.error(`mafit: failed to start binary: ${binaryPath}`);
+    console.error(result.error.message);
+    process.exit(1);
+  }
+
+  if (typeof result.status === "number") {
+    process.exit(result.status);
+  }
+
+  process.exit(1);
+};
+
+run().catch((error) => {
+  console.error("mafit: unexpected launcher error");
+  console.error(error && error.message ? error.message : String(error));
+  process.exit(1);
+});

package/package.json

@@ -1,18 +1,23 @@
 {
   "name": "mafit",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "mafit tui app",
+  "mafitBinaryPackage": "mafit",
+  "mafitBinaryVersionSuffix": "-bin.0",
   "bin": {
     "mafit": "dist/bin/mafit.cjs"
   },
   "files": [
-    "dist/bin/**"
+    "dist/bin/mafit.cjs"
   ],
   "scripts": {
     "sync:rust-version": "node scripts/sync-rust-version.cjs",
     "clean": "node scripts/clean-dist.cjs",
     "build:rust": "node scripts/build-rust.cjs",
     "build:launcher": "node scripts/build-launcher.cjs",
+    "prepare:binaries:pkg": "node scripts/prepare-binaries-package.cjs",
+    "pack:binaries:pkg": "npm run prepare:binaries:pkg && npm pack --dry-run .release/mafit-binaries",
+    "publish:binaries:pkg": "npm run prepare:binaries:pkg && npm publish .release/mafit-binaries --access public --tag binaries",
     "stage:binary": "node scripts/stage-binary.cjs",
     "verify:binaries": "node scripts/verify-release-binaries.cjs",
     "verify:binaries:core": "node scripts/verify-release-binaries.cjs --required linux-x64,win32-x64",
@@ -20,7 +25,7 @@
     "build:target": "npm run sync:rust-version && npm run build:rust && npm run build:launcher",
     "start": "node scripts/run-bin.cjs",
     "dev": "npm run build && npm run start",
-    "prepack": "npm run build:launcher && npm run verify:binaries:core"
+    "prepack": "npm run build:launcher"
   },
   "license": "MIT"
 }