roxify 1.14.1 → 1.14.3

package/dist/cli.js

@@ -3,7 +3,7 @@ import { readdirSync, readFileSync, statSync, writeFileSync } from 'fs';
 import { open } from 'fs/promises';
 import { basename, dirname, join, resolve } from 'path';
 import * as cliProgress from './stub-progress.js';
-import { encodeWithRustCLI, havepassphraseWithRustCLI, isRustBinaryAvailable, listWithRustCLI, } from './utils/rust-cli-wrapper.js';
+import { decodeWithRustCLI, encodeWithRustCLI, havepassphraseWithRustCLI, isRustBinaryAvailable, listWithRustCLI, } from './utils/rust-cli-wrapper.js';
 async function loadJsEngine() {
     const indexMod = await import('./index.js');
     const packMod = await import('./pack.js');
@@ -20,7 +20,7 @@ async function loadJsEngine() {
         VFSIndexEntry: undefined,
     };
 }
-const VERSION = '1.14.0';
+const VERSION = '1.14.3';
 function getDirectorySize(dirPath) {
     let totalSize = 0;
     try {
@@ -462,6 +462,38 @@ async function encodeCommand(args) {
         else {
             const resolvedInput = resolvedInputs[0];
             const st = statSync(resolvedInput);
+            // Calculate total size for deciding whether to use Rust CLI streaming
+            const totalInputSize = st.isDirectory()
+                ? getDirectorySize(resolvedInput)
+                : st.size;
+            // Use Rust CLI for large files (> 1GB) to avoid Buffer.concat 4GB limit
+            const STREAMING_THRESHOLD = 1024 * 1024 * 1024; // 1GB
+            if (totalInputSize > STREAMING_THRESHOLD && isRustBinaryAvailable()) {
+                console.log('Using native Rust encoder (streaming for large payload)\n');
+                const encodeStart = Date.now();
+                let lastPct = 0;
+                await encodeWithRustCLI(resolvedInput, resolvedOutput, parsed.level ? Number(parsed.level) : 6, parsed.passphrase, parsed.encrypt || 'aes', parsed.outputName || (st.isDirectory() ? basename(resolvedInput) : undefined), undefined, // ramBudgetMb
+                (current, total, step) => {
+                    const pct = Math.floor((current / total) * 100);
+                    if (pct !== lastPct) {
+                        lastPct = pct;
+                        if (barStarted) {
+                            encodeBar.update(pct, { step });
+                        }
+                    }
+                });
+                const encodeTime = Date.now() - encodeStart;
+                if (barStarted) {
+                    encodeBar.update(100, { step: 'done', elapsed: String(Math.floor(encodeTime / 1000)) });
+                    encodeBar.stop();
+                }
+                console.log(`\nSuccess!`);
+                console.log(`  Input:  ${(totalInputSize / 1024 / 1024).toFixed(2)} MB`);
+                console.log(`  Time:   ${encodeTime}ms`);
+                console.log(`  Saved:  ${resolvedOutput}`);
+                console.log(' ');
+                return;
+            }
             if (st.isDirectory()) {
                 currentEncodeStep = 'Reading files';
                 const { index, stream, totalSize } = await js.packPathsGenerator([resolvedInput], dirname(resolvedInput), onProgress);
@@ -591,33 +623,24 @@ async function decodeCommand(args) {
     }
     const resolvedInput = resolve(inputPath);
     const resolvedOutput = parsed.output || outputPath || '.';
+    if (!isRustBinaryAvailable()) {
+        console.error('Error: Rust decoder binary not found');
+        process.exit(1);
+    }
     try {
         console.log(' ');
         console.log('Decoding... (Using native Rust decoder)\n');
         const startTime = Date.now();
         const decodeBar = new cliProgress.SingleBar({ format: ' {bar} {percentage}% | {step} | {elapsed}s' }, cliProgress.Presets.shades_classic);
         decodeBar.start(100, 0, { step: 'Decoding', elapsed: '0' });
-        const js = await loadJsEngine();
-        const result = await js.decodePngToBinary(readFileSync(resolvedInput));
-        if (result.files && result.files.length > 0) {
-            const outputDir = resolve(resolvedOutput);
-            for (const file of result.files) {
-                const dest = join(outputDir, file.path);
-                const parent = dirname(dest);
-                try {
-                    await import('fs/promises').then(({ mkdir }) => mkdir(parent, { recursive: true }));
-                }
-                catch { }
-                writeFileSync(dest, file.buf);
-            }
-        }
-        else if (result.buf) {
-            const outputFile = resolvedOutput === '.' ? join(process.cwd(), result.meta?.name || basename(resolvedInput).replace(/\.[^.]+$/, '')) : resolvedOutput;
-            writeFileSync(outputFile, result.buf);
-        }
-        else {
-            throw new Error('Decoded result is empty');
-        }
+        await decodeWithRustCLI(resolvedInput, resolvedOutput, parsed.passphrase, parsed.files, parsed.dict, parsed.ramBudgetMb, (current, total, step) => {
+            const pct = total > 0 ? Math.floor((current / total) * 100) : 0;
+            const elapsed = Math.floor((Date.now() - startTime) / 1000);
+            decodeBar.update(Math.min(pct, 99), {
+                step: step || 'Decoding',
+                elapsed: String(elapsed),
+            });
+        });
         const decodeTime = Date.now() - startTime;
         decodeBar.update(100, { step: 'done', elapsed: String(Math.floor(decodeTime / 1000)) });
         decodeBar.stop();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roxify",
-  "version": "1.14.1",
+  "version": "1.14.3",
   "type": "module",
   "description": "Ultra-lightweight PNG steganography with native Rust acceleration. Encode binary data into PNG images with zstd compression.",
   "main": "dist/index.js",
@@ -12,11 +12,8 @@
   "files": [
     "dist/**/*.js",
     "dist/**/*.d.ts",
-    "dist/roxify_native*",
-    "dist/rox-macos-universal",
     "scripts/postinstall.cjs",
-    "roxify_native-*.node",
-    "libroxify_native-*.node",
+    "scripts/download-binary.cjs",
     "README.md",
     "LICENSE"
   ],
@@ -96,4 +93,4 @@
     "node": ">=18.0.0"
   },
   "dependencies": {}
-}
+}

package/scripts/download-binary.cjs

@@ -0,0 +1,259 @@
+const https = require('https');
+const { createWriteStream, existsSync, mkdirSync, chmodSync, unlinkSync } = require('fs');
+const { join } = require('path');
+const { platform, arch } = require('os');
+
+const GITHUB_REPO = 'RoxasYTB/roxify';
+const DIST_DIR = join(__dirname, '..', 'dist');
+const root = join(__dirname, '..');
+
+function getPlatformBinary() {
+    const os = platform();
+    const cpu = arch();
+
+    const map = {
+        linux: { x64: 'roxify_native', arm64: 'roxify_native' },
+        win32: { x64: 'roxify_native.exe', arm64: 'roxify_native.exe' },
+        darwin: { x64: 'rox-macos-universal', arm64: 'rox-macos-universal' },
+    };
+
+    return (map[os] && map[os][cpu]) || null;
+}
+
+function getReleaseAssetName(version) {
+    const os = platform();
+    const cpu = arch();
+
+    // Map platform/arch to release asset names as uploaded by GitHub Actions
+    const map = {
+        linux: {
+            x64: `roxify_native-x86_64-unknown-linux-gnu`,
+            arm64: `roxify_native-aarch64-unknown-linux-gnu`
+        },
+        win32: {
+            x64: `roxify_native-x86_64-pc-windows-msvc.exe`,
+            arm64: `roxify_native-aarch64-pc-windows-msvc.exe`
+        },
+        darwin: {
+            x64: `rox-macos-universal`,
+            arm64: `rox-macos-universal`
+        },
+    };
+
+    return (map[os] && map[os][cpu]) || null;
+}
+
+function getNativeLibAssetName(version) {
+    const os = platform();
+    const cpu = arch();
+
+    const triples = {
+        linux: { x64: 'x86_64-unknown-linux-gnu', arm64: 'aarch64-unknown-linux-gnu' },
+        win32: { x64: 'x86_64-pc-windows-msvc', arm64: 'aarch64-pc-windows-msvc' },
+        darwin: { x64: 'x86_64-apple-darwin', arm64: 'aarch64-apple-darwin' },
+    };
+
+    const triple = triples[os] && triples[os][cpu];
+    if (!triple) return null;
+
+    return `roxify_native-${triple}.node`;
+}
+
+function downloadFile(url, dest, maxRedirects = 5) {
+    return new Promise((resolve, reject) => {
+        if (maxRedirects <= 0) {
+            reject(new Error('Too many redirects'));
+            return;
+        }
+
+        const file = createWriteStream(dest);
+        const request = https.get(url, { timeout: 60000 }, (response) => {
+            // Handle redirects
+            if (response.statusCode === 302 || response.statusCode === 301) {
+                const location = response.headers.location;
+                if (location) {
+                    file.close();
+                    // Clean up partial file
+                    try { unlinkSync(dest); } catch { }
+                    downloadFile(location, dest, maxRedirects - 1).then(resolve).catch(reject);
+                    return;
+                }
+            }
+
+            if (response.statusCode !== 200) {
+                file.close();
+                try { unlinkSync(dest); } catch { }
+                reject(new Error(`HTTP ${response.statusCode} for ${url}`));
+                return;
+            }
+
+            let downloaded = 0;
+            response.on('data', (chunk) => {
+                downloaded += chunk.length;
+            });
+
+            response.pipe(file);
+
+            file.on('finish', () => {
+                file.close();
+                console.log(`roxify: Downloaded ${(downloaded / 1024 / 1024).toFixed(2)} MB`);
+                resolve();
+            });
+        });
+
+        request.on('error', (err) => {
+            file.close();
+            try { unlinkSync(dest); } catch { }
+            reject(err);
+        });
+
+        request.on('timeout', () => {
+            request.destroy();
+            file.close();
+            try { unlinkSync(dest); } catch { }
+            reject(new Error('Request timeout'));
+        });
+    });
+}
+
+async function getLatestReleaseVersion() {
+    const url = `https://api.github.com/repos/${GITHUB_REPO}/releases/latest`;
+
+    return new Promise((resolve, reject) => {
+        https.get(url, {
+            headers: {
+                'User-Agent': 'roxify-install',
+                'Accept': 'application/vnd.github.v3+json'
+            },
+            timeout: 10000
+        }, (response) => {
+            if (response.statusCode !== 200) {
+                reject(new Error(`GitHub API HTTP ${response.statusCode}`));
+                return;
+            }
+
+            let data = '';
+            response.on('data', chunk => data += chunk);
+            response.on('end', () => {
+                try {
+                    const release = JSON.parse(data);
+                    const version = release.tag_name.replace(/^v/, '');
+                    resolve(version);
+                } catch (e) {
+                    reject(new Error('Failed to parse GitHub API response'));
+                }
+            });
+        }).on('error', reject).on('timeout', function () { this.destroy(); reject(new Error('API timeout')); });
+    });
+}
+
+async function downloadBinary() {
+    let version;
+    try {
+        version = require('../package.json').version;
+    } catch (e) {
+        version = '1.14.2';
+    }
+
+    // Try to get latest release version from GitHub
+    try {
+        const latestVersion = await getLatestReleaseVersion();
+        if (latestVersion && latestVersion !== version) {
+            console.log(`roxify: Latest release is v${latestVersion} (package is v${version})`);
+            version = latestVersion;
+        }
+    } catch (e) {
+        console.log(`roxify: Using package version v${version} (could not check latest: ${e.message})`);
+    }
+
+    const binaryName = getPlatformBinary();
+    const assetName = getReleaseAssetName(version);
+
+    if (!binaryName || !assetName) {
+        console.log(`roxify: Unsupported platform ${platform()}/${arch()}`);
+        return false;
+    }
+
+    if (!existsSync(DIST_DIR)) {
+        mkdirSync(DIST_DIR, { recursive: true });
+    }
+
+    const destPath = join(DIST_DIR, binaryName);
+
+    // Check if already exists
+    if (existsSync(destPath)) {
+        console.log(`roxify: CLI binary already exists at ${destPath}`);
+        return true;
+    }
+
+    const url = `https://github.com/${GITHUB_REPO}/releases/download/v${version}/${assetName}`;
+
+    console.log(`roxify: Downloading ${assetName} from GitHub...`);
+    console.log(`roxify: URL: ${url}`);
+
+    try {
+        await downloadFile(url, destPath);
+
+        if (platform() !== 'win32') {
+            try { chmodSync(destPath, 0o755); } catch { }
+        }
+
+        console.log(`roxify: CLI binary ready at ${destPath}`);
+        return true;
+    } catch (e) {
+        console.log(`roxify: Download failed: ${e.message}`);
+        // Clean up partial download
+        try { unlinkSync(destPath); } catch { }
+        return false;
+    }
+}
+
+async function downloadNativeLib() {
+    let version;
+    try {
+        version = require('../package.json').version;
+    } catch (e) {
+        version = '1.14.2';
+    }
+
+    // Try to get latest release version from GitHub
+    try {
+        const latestVersion = await getLatestReleaseVersion();
+        if (latestVersion && latestVersion !== version) {
+            version = latestVersion;
+        }
+    } catch (e) {
+        // Use package version
+    }
+
+    const assetName = getNativeLibAssetName(version);
+
+    if (!assetName) {
+        console.log(`roxify: Unsupported platform for native lib ${platform()}/${arch()}`);
+        return false;
+    }
+
+    const destPath = join(root, assetName);
+
+    // Check if already exists
+    if (existsSync(destPath)) {
+        console.log(`roxify: Native lib already exists at ${destPath}`);
+        return true;
+    }
+
+    const url = `https://github.com/${GITHUB_REPO}/releases/download/v${version}/${assetName}`;
+
+    console.log(`roxify: Downloading native lib ${assetName}...`);
+
+    try {
+        await downloadFile(url, destPath);
+        console.log(`roxify: Native lib ready at ${destPath}`);
+        return true;
+    } catch (e) {
+        console.log(`roxify: Native lib download failed: ${e.message}`);
+        try { unlinkSync(destPath); } catch { }
+        return false;
+    }
+}
+
+module.exports = { downloadBinary, downloadNativeLib, getPlatformBinary, getLatestReleaseVersion };

package/scripts/postinstall.cjs

@@ -1,11 +1,20 @@
 const { execSync } = require('child_process');
-const { existsSync, copyFileSync, mkdirSync, readdirSync, unlinkSync } = require('fs');
+const { existsSync, copyFileSync, mkdirSync, readdirSync, unlinkSync, chmodSync } = require('fs');
 const { join } = require('path');
 const { platform, arch } = require('os');
 
 const root = join(__dirname, '..');
 const distDir = join(root, 'dist');
 
+// Try to import download helper
+try {
+      var { downloadBinary, downloadNativeLib } = require('./download-binary.cjs');
+} catch (e) {
+      console.log('roxify: Download helper not available, will use local build only');
+      var downloadBinary = null;
+      var downloadNativeLib = null;
+}
+
 function hasCargo() {
       try {
             execSync('cargo --version', { stdio: 'ignore', timeout: 5000 });
@@ -18,165 +27,182 @@ function getTriples() {
       const cpu = arch();
       const map = {
             linux: { x64: ['x86_64-unknown-linux-gnu'], arm64: ['aarch64-unknown-linux-gnu'] },
-            win32: { x64: ['x86_64-pc-windows-msvc', 'x86_64-pc-windows-gnu'], arm64: ['aarch64-pc-windows-msvc'] },
+            win32: { x64: ['x86_64-pc-windows-msvc'], arm64: ['aarch64-pc-windows-msvc'] },
             darwin: { x64: ['x86_64-apple-darwin'], arm64: ['aarch64-apple-darwin'] },
       };
       return (map[os] && map[os][cpu]) || [];
 }
 
-function getLibExt() {
-      if (platform() === 'win32') return 'dll';
-      if (platform() === 'darwin') return 'dylib';
-      return 'so';
-}
-
 function getBinaryName() {
       return platform() === 'win32' ? 'roxify_native.exe' : 'roxify_native';
 }
 
-function findExistingBinary() {
-      const name = getBinaryName();
-      const triples = getTriples();
-      const candidates = [join(distDir, name), join(root, 'target', 'release', name)];
-      for (const t of triples) {
-            candidates.push(join(root, 'target', t, 'release', name));
-      }
-      for (const c of candidates) {
-            if (existsSync(c)) return c;
-      }
-      return null;
+function getMacosBinaryName() {
+      return 'rox-macos-universal';
 }
 
-function findExistingNativeLib() {
-      const triples = getTriples();
-      const ext = getLibExt();
-      const prefix = platform() === 'win32' ? '' : 'lib';
-      for (const t of triples) {
-            const specific = join(root, `roxify_native-${t}.node`);
-            if (existsSync(specific)) return { path: specific, triple: t };
-      }
-      for (const t of triples) {
-            for (const profile of ['release', 'fastdev']) {
-                  const paths = [
-                        join(root, 'target', t, profile, `${prefix}roxify_native.${ext}`),
-                        join(root, 'target', profile, `${prefix}roxify_native.${ext}`),
-                  ];
-                  for (const p of paths) {
-                        if (existsSync(p)) return { path: p, triple: t };
-                  }
-            }
-      }
-      return null;
-}
-
-function buildNative(target) {
-      if (!hasCargo()) return false;
-      const args = target ? ` --target ${target}` : '';
-      console.log(`roxify: Building native lib${args}...`);
-      try {
-            execSync(`cargo build --release --lib${args}`, { cwd: root, stdio: 'inherit', timeout: 600000 });
-            return true;
-      } catch {
-            console.log('roxify: Native lib build failed');
-            return false;
-      }
-}
-
-function buildBinary() {
+function buildBinaryLocally() {
       if (!hasCargo()) {
-            console.log('roxify: Cargo not found, skipping native build (TypeScript fallback will be used)');
+            console.log('roxify: Cargo not found, will try to download prebuilt binary');
             return false;
       }
-      console.log('roxify: Building native CLI binary...');
+      console.log('roxify: Building native CLI binary locally...');
       try {
             execSync('cargo build --release --bin roxify_native', { cwd: root, stdio: 'inherit', timeout: 600000 });
             return true;
-      } catch {
-            console.log('roxify: Native build failed, TypeScript fallback will be used');
+      } catch (e) {
+            console.log('roxify: Local build failed, will try to download prebuilt binary');
             return false;
       }
 }
 
-function ensureCliBinary() {
+async function ensureCliBinary() {
       if (!existsSync(distDir)) mkdirSync(distDir, { recursive: true });
-      const dest = join(distDir, getBinaryName());
-      if (existsSync(dest)) return;
 
-      const existing = findExistingBinary();
-      if (existing && existing !== dest) {
-            copyFileSync(existing, dest);
+      const binaryName = platform() === 'darwin' ? getMacosBinaryName() : getBinaryName();
+      const dest = join(distDir, binaryName);
+
+      if (existsSync(dest)) {
+            console.log(`roxify: CLI binary already exists at ${dest}`);
+            return true;
+      }
+
+      // Check if built locally exists
+      const localBuilt = join(root, 'target', 'release', getBinaryName());
+      if (existsSync(localBuilt)) {
+            copyFileSync(localBuilt, dest);
             if (platform() !== 'win32') {
-                  try { require('fs').chmodSync(dest, 0o755); } catch { }
+                  try { chmodSync(dest, 0o755); } catch { }
             }
-            console.log(`roxify: Copied CLI binary from ${existing}`);
-            return;
+            console.log(`roxify: CLI binary copied from local build`);
+            return true;
+      }
+
+      if (process.env.ROXIFY_SKIP_BUILD === '1') return false;
+
+      // PRIMARY: Try download from GitHub releases (fast, no compilation)
+      if (downloadBinary && !process.env.ROXIFY_FORCE_LOCAL_BUILD) {
+            console.log(`roxify: Attempting to download prebuilt binary from GitHub...`);
+            const downloaded = await downloadBinary();
+            if (downloaded) {
+                  console.log(`roxify: Successfully downloaded prebuilt binary`);
+                  return true;
+            }
+            console.log(`roxify: Download failed, will try local build...`);
       }
-      if (existing) return;
-      if (process.env.ROXIFY_SKIP_BUILD === '1') return;
 
-      if (buildBinary()) {
-            const built = join(root, 'target', 'release', getBinaryName());
-            if (existsSync(built)) {
-                  copyFileSync(built, dest);
+      // FALLBACK: Try local build (requires Cargo)
+      if (buildBinaryLocally()) {
+            if (existsSync(localBuilt)) {
+                  copyFileSync(localBuilt, dest);
                   if (platform() !== 'win32') {
-                        try { require('fs').chmodSync(dest, 0o755); } catch { }
+                        try { chmodSync(dest, 0o755); } catch { }
                   }
-                  console.log('roxify: CLI binary built and copied to dist/');
+                  console.log(`roxify: CLI binary built locally`);
+                  return true;
             }
       }
+
+      console.log('roxify: No native binary available, TypeScript fallback will be used');
+      return false;
 }
 
-function ensureNativeLib() {
+async function ensureNativeLib() {
       const triples = getTriples();
       if (!triples.length) return;
 
-      for (const t of triples) {
-            if (existsSync(join(root, `roxify_native-${t}.node`))) return;
-      }
+      const triple = triples[0];
+      const dest = join(root, `roxify_native-${triple}.node`);
+
+      if (existsSync(dest)) return;
+
+      // Check if built locally
+      const ext = platform() === 'win32' ? 'dll' : (platform() === 'darwin' ? 'dylib' : 'so');
+      const prefix = platform() === 'win32' ? '' : 'lib';
+      const localBuilt = join(root, 'target', 'release', `${prefix}roxify_native.${ext}`);
 
-      const found = findExistingNativeLib();
-      if (found) {
-            const dest = join(root, `roxify_native-${found.triple}.node`);
-            copyFileSync(found.path, dest);
-            console.log(`roxify: Copied native lib → ${dest}`);
+      if (existsSync(localBuilt)) {
+            copyFileSync(localBuilt, dest);
+            console.log(`roxify: Native lib copied from local build → ${dest}`);
             return;
       }
 
       if (process.env.ROXIFY_SKIP_BUILD === '1') return;
 
-      const triple = triples[0];
-      if (buildNative(null)) {
-            const ext = getLibExt();
-            const prefix = platform() === 'win32' ? '' : 'lib';
-            const built = join(root, 'target', 'release', `${prefix}roxify_native.${ext}`);
-            if (existsSync(built)) {
-                  const dest = join(root, `roxify_native-${triple}.node`);
-                  copyFileSync(built, dest);
-                  console.log(`roxify: Native lib built → ${dest}`);
+      // PRIMARY: Try download from GitHub releases
+      if (downloadNativeLib && !process.env.ROXIFY_FORCE_LOCAL_BUILD) {
+            console.log(`roxify: Attempting to download native lib from GitHub...`);
+            const downloaded = await downloadNativeLib();
+            if (downloaded) {
+                  console.log(`roxify: Successfully downloaded native lib`);
+                  return;
             }
+            console.log(`roxify: Native lib download failed, will try local build...`);
       }
-}
 
-if (process.env.ROXIFY_ENABLE_RUST_CLI === '1') {
-      ensureCliBinary();
+      // FALLBACK: Try build locally
+      if (hasCargo()) {
+            console.log(`roxify: Building native lib locally...`);
+            try {
+                  execSync('cargo build --release --lib', { cwd: root, stdio: 'inherit', timeout: 600000 });
+                  if (existsSync(localBuilt)) {
+                        copyFileSync(localBuilt, dest);
+                        console.log(`roxify: Native lib built locally → ${dest}`);
+                  }
+            } catch {
+                  console.log('roxify: Native lib build failed, TypeScript fallback will be used');
+            }
+      }
 }
-ensureNativeLib();
 
-// Cleanup: remove other platform .node artifacts to reduce disk usage after install
+// Always ensure CLI binary is available (download first, build as fallback)
+(async () => {
+      await ensureCliBinary();
+      await ensureNativeLib();
+
+      // Summary
+      console.log('');
+      console.log('roxify: Post-install complete');
+      console.log(`roxify: Platform: ${platform()}/${arch()}`);
+      if (!existsSync(join(distDir, platform() === 'darwin' ? getMacosBinaryName() : getBinaryName()))) {
+            console.log('roxify: WARNING: No native CLI binary available - will use TypeScript fallback');
+      }
+})();
+
+// Cleanup: remove ALL other platform .node artifacts
 try {
       const triples = getTriples();
-      if (triples && triples.length) {
-            const files = readdirSync(root);
-            for (const f of files) {
-                  // match roxify_native-<triple>.node or libroxify_native-<triple>.node
-                  const m = f.match(/^(lib)?roxify_native-(.+)\.node$/);
-                  if (m) {
-                        const fileTriple = m[2];
-                        // keep if fileTriple is one of the allowed triples
-                        if (!triples.includes(fileTriple)) {
-                              try { unlinkSync(join(root, f)); console.log(`roxify: removed ${f}`); } catch (e) { }
-                        }
+      const files = readdirSync(root);
+      for (const f of files) {
+            const m = f.match(/^roxify_native-(.+)\.node$/);
+            if (m) {
+                  const fileTriple = m[1];
+                  if (!triples.includes(fileTriple)) {
+                        try {
+                              unlinkSync(join(root, f));
+                              console.log(`roxify: removed unused native lib ${f}`);
+                        } catch (e) { }
                   }
             }
       }
 } catch (e) { }
+
+// Cleanup: remove ALL other platform CLI binaries from dist/
+try {
+      const os = platform();
+      const distFiles = existsSync(distDir) ? readdirSync(distDir) : [];
+      const keepName = os === 'darwin' ? getMacosBinaryName() : getBinaryName();
+
+      for (const f of distFiles) {
+            // Skip if it's the correct binary for this platform
+            if (f === keepName) continue;
+
+            // Remove any roxify_native binary
+            if (f.match(/^roxify_native/) || f === 'rox-macos-universal') {
+                  try {
+                        unlinkSync(join(distDir, f));
+                        console.log(`roxify: removed unused binary dist/${f}`);
+                  } catch (e) { }
+            }
+      }
+} catch (e) { }