@airmoney-degn/airmoney-cli 0.12.2 → 0.13.0

package/dist/cli/serve.js

@@ -28,6 +28,17 @@ function getSimulatorDir() {
     return path_1.default.join(base, 'public', 'simulator');
 }
 async function serveCommand(noBrowser, locationFolder, appUrl) {
+    // Check if simulator and API ports are already in use (crypto service handles its own port)
+    const requiredPorts = [4040, 4041, 5050];
+    const inUsePorts = await (0, cryptoProcess_1.checkPortsInUse)(requiredPorts);
+    if (inUsePorts.length > 0) {
+        console.error('\x1b[31m❌ Port conflict detected!\x1b[0m');
+        console.error(`\x1b[31mThe following ports are already in use: ${inUsePorts.join(', ')}\x1b[0m`);
+        console.error('\x1b[31m\nPlease kill the processes using these ports before running serve:\x1b[0m');
+        const killCommand = `lsof -ti:${inUsePorts.join(',')} | xargs kill -9`;
+        console.error(`\x1b[31m  ${killCommand}\x1b[0m`);
+        process.exit(1);
+    }
     const simulatorPort = 4041;
     const simulatorExpress = (0, express_ws_1.default)((0, express_1.default)()).app;
     simulatorExpress.use((0, cors_1.default)());
@@ -38,7 +49,7 @@ async function serveCommand(noBrowser, locationFolder, appUrl) {
         ws.on('message', function (msg) {
             console.log(msg);
         });
-        console.log('socket', req.body);
+        // console.log('socket', req.body);
     });
     const simulatorDir = getSimulatorDir();
     simulatorExpress.use('/simulator', express_1.default.static(simulatorDir));
@@ -49,7 +60,7 @@ async function serveCommand(noBrowser, locationFolder, appUrl) {
     }
     const metadata = (0, metadata_1.loadMetadata)();
     if (!metadata) {
-        console.log('[Warning] No metadata found. Skipping some possible checks.');
+        console.log('\x1b[33mNo metadata found. Skipping some possible checks.\x1b[0m');
     }
     if (appUrl != undefined) {
         const proxyMiddleware = (0, http_proxy_middleware_1.createProxyMiddleware)({
@@ -65,14 +76,14 @@ async function serveCommand(noBrowser, locationFolder, appUrl) {
     }
     const simulatorServer = simulatorExpress.listen(simulatorPort, () => {
         const url = `http://localhost:${simulatorPort}/simulator`;
-        console.log(`Starting simulator server at ${url}`);
+        console.log(`\x1b[32mStarting simulator server at ${url}\x1b[0m`);
         if (!noBrowser) {
             (0, open_1.default)(url)
                 .then(() => {
                 // success opening URL
             })
                 .catch(err => {
-                console.error('Failed to open web browser', err);
+                console.error('\x1b[31mFailed to open web browser\x1b[0m', err);
             });
         }
     });
@@ -99,7 +110,7 @@ async function serveCommand(noBrowser, locationFolder, appUrl) {
                     return;
                 }
                 else {
-                    console.log('Warning: No simulator client connected');
+                    console.log('\x1b[33mNo simulator client connected\x1b[0m');
                     res.status(503).json({ error: 'Simulator not connected' });
                     return;
                 }
@@ -116,7 +127,7 @@ async function serveCommand(noBrowser, locationFolder, appUrl) {
     });
     const airmoneyServiceServer = airmoneyServiceExpress.listen(airmoneyServicePort, () => {
         const url = `http://localhost:${airmoneyServicePort}`;
-        console.log(`Starting airmoney service server at ${url}`);
+        console.log(`\x1b[32mStarting airmoney service server at ${url}\x1b[0m`);
     });
     ////////////////////////////////////////////////////////////////
     (0, cryptoProcess_1.startCryptoServiceSimple)();

package/dist/config.json

@@ -1,3 +1,3 @@
 {
-    "version": "0.12.2"
+    "version": "0.13.0"
 }

package/dist/util/cryptoProcess.js

@@ -3,6 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPortInUse = isPortInUse;
+exports.checkPortsInUse = checkPortsInUse;
+exports.isCryptoServiceRunning = isCryptoServiceRunning;
 exports.startCryptoService = startCryptoService;
 exports.getCryptoServicePath = getCryptoServicePath;
 exports.startCryptoServiceSimple = startCryptoServiceSimple;
@@ -13,15 +16,83 @@ const path_1 = __importDefault(require("path"));
 const child_process_1 = require("child_process");
 const env_1 = require("./env");
 const CryptoService_1 = require("../service/crypto/CryptoService");
+// Utility functions for port management
+function isPortInUse(port) {
+    return new Promise(resolve => {
+        const net = require('net');
+        const socket = new net.Socket();
+        socket.setTimeout(1000);
+        socket.on('connect', () => {
+            socket.destroy();
+            resolve(true); // Port is in use
+        });
+        socket.on('timeout', () => {
+            socket.destroy();
+            resolve(false); // Port is free
+        });
+        socket.on('error', () => {
+            resolve(false); // Port is free
+        });
+        socket.connect(port, 'localhost');
+    });
+}
+async function checkPortsInUse(ports) {
+    const inUsePorts = [];
+    for (const port of ports) {
+        if (await isPortInUse(port)) {
+            inUsePorts.push(port);
+        }
+    }
+    return inUsePorts;
+}
+async function isCryptoServiceRunning(port = 5050) {
+    try {
+        // Check if crypto service is running by making a simple HTTP request
+        const response = await fetch(`http://localhost:${port}/`, {
+            method: 'GET',
+            signal: AbortSignal.timeout(1000), // 1 second timeout
+        });
+        // Accept any response (200, 404, 405, etc.) as long as we get a response
+        // This means the crypto service is running
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function startCryptoService() {
-    return new Promise((resolve, reject) => {
+    return new Promise(async (resolve, reject) => {
         const bin = getCryptoServicePath();
         if (!(0, fs_1.existsSync)(bin)) {
             reject(new Error(`Crypto service binary not found: ${bin}`));
             return;
         }
+        // Check if port 5050 is already in use before starting the binary
+        const portInUse = await isPortInUse(5050);
+        if (portInUse) {
+            // Check if it's our crypto service
+            const isCryptoRunning = await isCryptoServiceRunning(5050);
+            if (isCryptoRunning) {
+                // console.log('Reusing existing crypto service on port 5050');
+                // Return a mock process that doesn't need to be killed
+                resolve({
+                    process: null,
+                    kill: () => {
+                        // console.log('Crypto service is managed externally, not stopping');
+                    },
+                });
+                return;
+            }
+            else {
+                reject(new Error('Port 5050 is already in use by another service that is not the crypto service.\n' +
+                    'Please free up port 5050 or kill the conflicting process:\n' +
+                    '  lsof -ti:5050 | xargs kill -9'));
+                return;
+            }
+        }
         // console.log('Starting crypto service...');
         let isKilled = false;
+        let hasResolved = false;
         const cryptoProcess = (0, child_process_1.exec)(bin, {
             env: {
                 ...process.env,
@@ -30,29 +101,46 @@ function startCryptoService() {
             },
         }, (error, stdout, stderr) => {
             // Ignore errors if the process was intentionally killed
-            if (error && !isKilled) {
-                console.error('Crypto service error:', error);
-                reject(error);
+            if (error && !isKilled && !hasResolved) {
+                console.error('\x1b[31m❌ Crypto service failed to start:\x1b[0m');
+                console.error('\x1b[31mError details:\x1b[0m', error.message);
+                // Check for specific Rust panic errors
+                if (stderr &&
+                    stderr.includes('Cannot drop a runtime in a context where blocking is not allowed')) {
+                    console.error('\x1b[31m\n🔧 This appears to be a Rust/tokio runtime issue in the crypto service binary.\x1b[0m');
+                    console.error('\x1b[31mPossible solutions:\x1b[0m');
+                    console.error('\x1b[31m1. The binary may be corrupted - try rebuilding: npm run build\x1b[0m');
+                    console.error('\x1b[31m2. There may be a compatibility issue with your system\x1b[0m');
+                    console.error('\x1b[31m3. Try running the binary directly to see more details:\x1b[0m');
+                    console.error(`\x1b[31m   ${bin}\x1b[0m`);
+                }
+                else if (stderr) {
+                    console.error('Stderr:', stderr);
+                }
+                reject(new Error(`Crypto service failed: ${error.message}`));
                 return;
             }
-            // if (stdout) {
-            //   console.log('Crypto service stdout:', stdout);
-            // }
-            if (stderr) {
-                console.error('Crypto service stderr:', stderr);
+            if (stdout) {
+                // console.log('Crypto service stdout:', stdout);
+            }
+            if (stderr && !isKilled) {
+                console.error('\x1b[31mCrypto service stderr:\x1b[0m', stderr);
             }
         });
         // Wait 2 seconds before resolving to ensure service is ready
         setTimeout(() => {
-            resolve({
-                process: cryptoProcess,
-                kill: () => {
-                    isKilled = true;
-                    if (cryptoProcess && !cryptoProcess.killed) {
-                        cryptoProcess.kill();
-                    }
-                },
-            });
+            if (!hasResolved) {
+                hasResolved = true;
+                resolve({
+                    process: cryptoProcess,
+                    kill: () => {
+                        isKilled = true;
+                        if (cryptoProcess && !cryptoProcess.killed) {
+                            cryptoProcess.kill();
+                        }
+                    },
+                });
+            }
         }, 2000);
     });
 }
@@ -65,10 +153,10 @@ function getCryptoServicePath() {
 function startCryptoServiceSimple() {
     const bin = getCryptoServicePath();
     if (!(0, fs_1.existsSync)(bin)) {
-        console.log('crypto service not found at ' + bin);
+        console.log('\x1b[31mcrypto service not found at ' + bin + '\x1b[0m');
         return;
     }
-    console.log('execing crypto service at http://localhost:5050');
+    console.log('\x1b[32mStarting crypto service at http://localhost:5050\x1b[0m');
     (0, child_process_1.exec)(bin, { env: { SECURE_STORAGE: (0, env_1.configDir)(), RUST_BACKTRACE: '1' } }, (_, stdout, stderr) => {
         // console.log("stdout", stdout);
         // console.log("stderr", stderr);
@@ -88,8 +176,21 @@ async function withCryptoService(operation) {
     let cryptoService = null;
     let startedCryptoService = false;
     try {
-        cryptoService = await startCryptoService();
-        startedCryptoService = true;
+        // Start crypto service (this will check ports and reuse if available)
+        try {
+            cryptoService = await startCryptoService();
+            startedCryptoService = true;
+        }
+        catch (error) {
+            console.error('\x1b[31m❌ Failed to start crypto service:\x1b[0m');
+            console.error('\x1b[31mThis might be due to:\x1b[0m');
+            console.error('\x1b[31m- Missing or corrupted binary files\x1b[0m');
+            console.error('\x1b[31m- Insufficient permissions\x1b[0m');
+            console.error('\x1b[31m- System compatibility issues\x1b[0m');
+            console.error('\x1b[31m- Port conflicts\x1b[0m');
+            console.error('\x1b[31m\nTry running: npm run build\x1b[0m');
+            throw error;
+        }
         const cryptoServiceClient = new CryptoService_1.CryptoService();
         // console.log('Crypto service client created');
         return await operation(cryptoServiceClient);

package/dist/util/metadata.js

@@ -42,7 +42,7 @@ function loadMetadata(projectPath = '.') {
     try {
         const filePath = path.join(projectPath, 'metadata.json');
         if (!fs.existsSync(filePath)) {
-            console.log('Please run this command in Project directory');
+            console.log('\x1b[33mPlease run this command in Project directory\x1b[0m');
             return null;
         }
         const raw = fs.readFileSync(filePath, 'utf8');
@@ -50,7 +50,7 @@ function loadMetadata(projectPath = '.') {
         return data;
     }
     catch (err) {
-        console.log('Please run this command in Project directory');
+        console.log('\x1b[33mPlease run this command in Project directory\x1b[0m');
         return null;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@airmoney-degn/airmoney-cli",
-  "version": "0.12.2",
+  "version": "0.13.0",
   "description": "airmoney-cli is a command-line interface tool designed to facilitate the development and management of decentralized applications (DApps) for Airmoney.",
   "publishConfig": {
     "access": "public"