xpose-cli 0.4.4 → 0.4.6

package/bin/install.js

@@ -5,6 +5,7 @@ const path = require('path');
 const os = require('os');
 const https = require('https');
 const crypto = require('crypto');
+const { execSync } = require('child_process');
 
 /**
  * xpose binary downloader
@@ -150,7 +151,29 @@ async function download() {
             }
         }
 
-        console.log(`Successfully installed to ${dest}`);
+        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}"`);
+
+            // Ensure permissions on Unix
+            if (!isWin) {
+                const finalBinPath = path.join(BIN_DIR, binName);
+                fs.chmodSync(finalBinPath, 0o755);
+            }
+
+            // Cleanup the archive
+            fs.unlinkSync(dest);
+        } catch (e) {
+            console.error(`❌ Extraction failed: ${e.message}`);
+            process.exit(1);
+        }
+
+        console.log(`Successfully installed to ${BIN_DIR}`);
         console.log('Note: Run "xpose" to start the tunnel.');
 
     } catch (err) {

package/bin/test-install.js

@@ -2,24 +2,66 @@ 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 { execSync } = require('child_process');
+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 DUMMY_CONTENT = 'dummy binary content';
+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...');
+
+    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
+    execSync(`tar -czf "${archivePath}" -C "${TEST_DIR}" "${DUMMY_BIN}"`);
+    fs.unlinkSync(dummyBinPath); // Remove original dummy
 
-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';
+    // 3. Run extraction logic (simulating the end of install.js download)
+    console.log(`Extracting ${ARCHIVE_NAME}...`);
     try {
-        await download();
-        console.log('✅ testSuccessfulDownload passed (dev skip)');
+        execSync(`tar -xzf "${archivePath}" -C "${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 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 +82,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.4",
+    "version": "0.4.6",
     "description": "Cloudflare Tunnel CLI for developers - Vivid TUI, auto-copy, and smart defaults.",
     "bin": {
         "xpose": "bin/cli.js"