xpose-cli 0.4.5 → 0.4.7

package/bin/install.js

@@ -5,7 +5,7 @@ const path = require('path');
 const os = require('os');
 const https = require('https');
 const crypto = require('crypto');
-const { execSync } = require('child_process');
+const tar = require('tar');
 
 /**
  * xpose binary downloader
@@ -153,15 +153,17 @@ async function download() {
 
         console.log(`Extracting binary...`);
         try {
-            // Unpack the tar.gz archive
-            // xpose-target.tar.gz usually contains 'xpose' or 'xpose.exe'
-            const isWin = os.platform() === 'win32';
-            const binName = isWin ? 'xpose.exe' : 'xpose';
-
-            execSync(`tar -xzf "${dest}" -C "${BIN_DIR}"`);
+            // Unpack the tar.gz archive using the 'tar' package
+            // This is cross-platform and doesn't require the system 'tar' command
+            await tar.x({
+                file: dest,
+                cwd: BIN_DIR
+            });
 
             // Ensure permissions on Unix
+            const isWin = os.platform() === 'win32';
             if (!isWin) {
+                const binName = isWin ? 'xpose.exe' : 'xpose';
                 const finalBinPath = path.join(BIN_DIR, binName);
                 fs.chmodSync(finalBinPath, 0o755);
             }

package/bin/test-install.js

@@ -2,24 +2,74 @@ const assert = require('assert');
 const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
-const http = require('http'); // We'll use this to mock
+const tar = require('tar');
+const { getFileContent } = require('./install');
 
-// Mocking dependencies would be complex without a library like proxyquire or jest.
-// For a simple standalone test, we'll use environment variables and temporary paths.
+// Setup temporary test environment
+const TEST_DIR = path.join(__dirname, '..', 'test_tmp');
+const BIN_DIR = path.join(TEST_DIR, 'bin');
+const DUMMY_BIN = 'xpose';
+const ARCHIVE_NAME = 'test-target.tar.gz';
 
-const { download, getFileContent } = require('./install');
+if (!fs.existsSync(BIN_DIR)) {
+    fs.mkdirSync(BIN_DIR, { recursive: true });
+}
+
+async function testExtraction() {
+    console.log('Running testExtraction (using tar package)...');
+
+    const archivePath = path.join(BIN_DIR, ARCHIVE_NAME);
+    const dummyBinPath = path.join(TEST_DIR, DUMMY_BIN);
+
+    // 1. Create a dummy binary (make it a shell script so it's executable on Unix)
+    if (process.platform === 'win32') {
+        fs.writeFileSync(dummyBinPath, 'echo dummy');
+    } else {
+        fs.writeFileSync(dummyBinPath, '#!/bin/sh\necho "xpose version 0.0.0-test"');
+    }
+
+    // 2. Archive it using the 'tar' package (simulating CI build output)
+    await tar.c({
+        gzip: true,
+        file: archivePath,
+        cwd: TEST_DIR
+    }, [DUMMY_BIN]);
 
-async function testSuccessfulDownload() {
-    console.log('Running testSuccessfulDownload...');
-    // This is a minimal test to ensure the script doesn't crash
-    // and correctly identifies dev environment.
-    process.env.XPOSE_DEV = '1';
+    fs.unlinkSync(dummyBinPath); // Remove original dummy
+
+    // 3. Run extraction logic using the 'tar' package (simulating install.js)
+    console.log(`Extracting ${ARCHIVE_NAME}...`);
     try {
-        await download();
-        console.log('✅ testSuccessfulDownload passed (dev skip)');
+        await tar.x({
+            file: archivePath,
+            cwd: BIN_DIR
+        });
+
+        const extractedPath = path.join(BIN_DIR, DUMMY_BIN);
+        assert(fs.existsSync(extractedPath), 'Extracted binary should exist');
+
+        // Ensure permissions on Unix and test execution
+        if (process.platform !== 'win32') {
+            fs.chmodSync(extractedPath, 0o755);
+            const stats = fs.statSync(extractedPath);
+            assert((stats.mode & 0o777) === 0o755, 'Binary should have correct permissions');
+
+            console.log('Testing binary execution...');
+            const { execSync } = require('child_process');
+            const output = execSync(`"${extractedPath}"`).toString();
+            assert(output.includes('xpose version'), 'Binary should be executable and return expected output');
+            console.log('✅ Binary execution successful');
+        }
+
+        console.log('✅ testExtraction passed');
     } catch (e) {
-        console.error('❌ testSuccessfulDownload failed:', e);
+        console.error('❌ testExtraction failed:', e.message);
         process.exit(1);
+    } finally {
+        // Cleanup
+        if (fs.existsSync(archivePath)) fs.unlinkSync(archivePath);
+        const extractedPath = path.join(BIN_DIR, DUMMY_BIN);
+        if (fs.existsSync(extractedPath)) fs.unlinkSync(extractedPath);
     }
 }
 
@@ -40,13 +90,17 @@ async function testGetFileContent404() {
     }
 }
 
-// In a real scenario, we would mock https.get and fs.createWriteStream.
-// Since we want to stay within standard node tools for now, we'll verify the logic structure.
-
 async function runTests() {
-    await testSuccessfulDownload();
-    await testGetFileContent404();
-    console.log('\nAll tests passed!');
+    try {
+        await testExtraction();
+        await testGetFileContent404();
+        console.log('\n✨ All installation tests passed!');
+    } finally {
+        // Final cleanup of test directory
+        if (fs.existsSync(TEST_DIR)) {
+            fs.rmSync(TEST_DIR, { recursive: true, force: true });
+        }
+    }
 }
 
 runTests().catch(err => {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "xpose-cli",
-    "version": "0.4.5",
+    "version": "0.4.7",
     "description": "Cloudflare Tunnel CLI for developers - Vivid TUI, auto-copy, and smart defaults.",
     "bin": {
         "xpose": "bin/cli.js"
@@ -31,6 +31,7 @@
         "node": ">=16.0.0"
     },
     "dependencies": {
-        "cli-progress": "^3.12.0"
+        "cli-progress": "^3.12.0",
+        "tar": "^6.2.1"
     }
 }