@airmoney-degn/airmoney-cli 0.12.2 → 0.13.1

package/dist/cli/serve.js

@@ -1,123 +1,12 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.serveCommand = serveCommand;
-const path_1 = __importDefault(require("path"));
-const open_1 = __importDefault(require("open"));
-// var cors = require('cors')
-// import * as cors from "cors"
-const cors_1 = __importDefault(require("cors"));
-const express_1 = __importDefault(require("express"));
-const express_ws_1 = __importDefault(require("express-ws"));
-const metadata_1 = require("../util/metadata");
-const server_1 = require("../util/server");
-const http_proxy_middleware_1 = require("http-proxy-middleware");
-const cryptoProcess_1 = require("../util/cryptoProcess");
-/**
- * Helper to get the path to the "public/simulator" folder
- * from the distributed code. We use __dirname, then move
- * up two levels to the project root, then into public/simulator.
- */
-function getSimulatorDir() {
-    // after tsc compile, serve.js is in dist/cli/
-    // we step up two dirs to get back to the project root
-    // then go into public/simulator
-    const base = path_1.default.resolve(__dirname, '..', '..');
-    return path_1.default.join(base, 'public', 'simulator');
-}
+const ServeOrchestrator_1 = require("../service/serve/ServeOrchestrator");
 async function serveCommand(noBrowser, locationFolder, appUrl) {
-    const simulatorPort = 4041;
-    const simulatorExpress = (0, express_ws_1.default)((0, express_1.default)()).app;
-    simulatorExpress.use((0, cors_1.default)());
-    simulatorExpress.use(express_1.default.json());
-    let simulatorClient;
-    simulatorExpress.ws('/ws', function (ws, req) {
-        simulatorClient = ws;
-        ws.on('message', function (msg) {
-            console.log(msg);
-        });
-        console.log('socket', req.body);
-    });
-    const simulatorDir = getSimulatorDir();
-    simulatorExpress.use('/simulator', express_1.default.static(simulatorDir));
-    ////////////////////////////////////////////////////////////////
-    let projectFolder = process.cwd();
-    if (locationFolder != undefined) {
-        projectFolder = path_1.default.join(process.cwd(), locationFolder);
-    }
-    const metadata = (0, metadata_1.loadMetadata)();
-    if (!metadata) {
-        console.log('[Warning] No metadata found. Skipping some possible checks.');
-    }
-    if (appUrl != undefined) {
-        const proxyMiddleware = (0, http_proxy_middleware_1.createProxyMiddleware)({
-            xfwd: true,
-            target: appUrl,
-            changeOrigin: true,
-            pathFilter: '/',
-        });
-        simulatorExpress.use('/', proxyMiddleware);
-    }
-    else {
-        simulatorExpress.use('/', express_1.default.static(projectFolder));
-    }
-    const simulatorServer = simulatorExpress.listen(simulatorPort, () => {
-        const url = `http://localhost:${simulatorPort}/simulator`;
-        console.log(`Starting simulator server at ${url}`);
-        if (!noBrowser) {
-            (0, open_1.default)(url)
-                .then(() => {
-                // success opening URL
-            })
-                .catch(err => {
-                console.error('Failed to open web browser', err);
-            });
-        }
-    });
-    ////////////////////////////////////////////////////////////////
-    const airmoneyServicePort = 4040;
-    const airmoneyServiceExpress = (0, express_1.default)();
-    airmoneyServiceExpress.use((0, cors_1.default)());
-    airmoneyServiceExpress.use(express_1.default.json());
-    airmoneyServiceExpress.post('/', async (req, res) => {
-        let rpcReq = req.body;
-        let event;
-        let simulator = true;
-        switch (rpcReq.method) {
-            case 'setImage':
-            case 'setAnimate':
-                event = (0, server_1.displayImage)(rpcReq, metadata.name);
-                break;
-        }
-        if (simulator) {
-            if (event != null) {
-                if (simulatorClient) {
-                    simulatorClient.send(JSON.stringify(event));
-                    res.status(200).json({ success: true });
-                    return;
-                }
-                else {
-                    console.log('Warning: No simulator client connected');
-                    res.status(503).json({ error: 'Simulator not connected' });
-                    return;
-                }
-            }
-            else {
-                res.status(500).json({ error: 'Failed to process request' });
-                return;
-            }
-        }
-        else {
-            res.json({ jsonrpc: '2.0', result: event, id: 1 });
-            return;
-        }
-    });
-    const airmoneyServiceServer = airmoneyServiceExpress.listen(airmoneyServicePort, () => {
-        const url = `http://localhost:${airmoneyServicePort}`;
-        console.log(`Starting airmoney service server at ${url}`);
+    const orchestrator = new ServeOrchestrator_1.ServeOrchestrator({
+        noBrowser,
+        locationFolder,
+        appUrl,
     });
-    ////////////////////////////////////////////////////////////////
-    (0, cryptoProcess_1.startCryptoServiceSimple)();
+    await orchestrator.start();
 }

package/dist/config.json

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

package/dist/service/airmoney/AirmoneyService.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AirmoneyService = void 0;
+const express_1 = __importDefault(require("express"));
+const cors_1 = __importDefault(require("cors"));
+const server_1 = require("../../util/server");
+class AirmoneyService {
+    constructor(config) {
+        this.simulatorClient = null;
+        this.config = config;
+        this.app = (0, express_1.default)();
+        this.setupMiddleware();
+        this.setupRoutes();
+    }
+    setupMiddleware() {
+        this.app.use((0, cors_1.default)());
+        this.app.use(express_1.default.json());
+    }
+    setupRoutes() {
+        this.app.post('/', this.handleRpcRequest.bind(this));
+    }
+    async handleRpcRequest(req, res) {
+        const rpcReq = req.body;
+        let event;
+        const simulator = true;
+        switch (rpcReq.method) {
+            case 'setImage':
+            case 'setAnimate':
+                event = (0, server_1.displayImage)(rpcReq, this.config.metadata?.name || '');
+                break;
+        }
+        if (simulator) {
+            if (event != null) {
+                if (this.simulatorClient) {
+                    this.simulatorClient.send(JSON.stringify(event));
+                    res.status(200).json({ success: true });
+                    return;
+                }
+                else {
+                    console.log('\x1b[33mNo simulator client connected\x1b[0m');
+                    res.status(503).json({ error: 'Simulator not connected' });
+                    return;
+                }
+            }
+            else {
+                res.status(500).json({ error: 'Failed to process request' });
+                return;
+            }
+        }
+        else {
+            res.json({ jsonrpc: '2.0', result: event, id: 1 });
+            return;
+        }
+    }
+    setSimulatorClient(simulatorClient) {
+        this.simulatorClient = simulatorClient;
+    }
+    async start() {
+        return new Promise(resolve => {
+            this.server = this.app.listen(this.config.port, () => {
+                const url = `http://localhost:${this.config.port}`;
+                console.log(`\x1b[32mStarting airmoney service server at ${url}\x1b[0m`);
+                resolve();
+            });
+        });
+    }
+    async stop() {
+        return new Promise(resolve => {
+            if (this.server) {
+                this.server.close(() => {
+                    resolve();
+                });
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+}
+exports.AirmoneyService = AirmoneyService;

package/dist/service/airmoney/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/service/port/PortManager.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PortManager = void 0;
+const cryptoProcess_1 = require("../../util/cryptoProcess");
+class PortManager {
+    /**
+     * Check if any of the required ports are in use
+     */
+    static async checkPortConflicts(ports = this.DEFAULT_PORTS) {
+        const inUsePorts = await (0, cryptoProcess_1.checkPortsInUse)(ports);
+        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);
+        }
+    }
+    /**
+     * Get the default ports used by the application
+     */
+    static getDefaultPorts() {
+        return [...this.DEFAULT_PORTS];
+    }
+}
+exports.PortManager = PortManager;
+PortManager.DEFAULT_PORTS = [4040, 4041, 5050];

package/dist/service/serve/ServeOrchestrator.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServeOrchestrator = void 0;
+const path_1 = __importDefault(require("path"));
+const metadata_1 = require("../../util/metadata");
+const cryptoProcess_1 = require("../../util/cryptoProcess");
+const PortManager_1 = require("../port/PortManager");
+const SimulatorService_1 = require("../simulator/SimulatorService");
+const AirmoneyService_1 = require("../airmoney/AirmoneyService");
+class ServeOrchestrator {
+    constructor(config) {
+        this.config = config;
+        this.metadata = (0, metadata_1.loadMetadata)();
+        this.simulatorService = this.createSimulatorService();
+        this.airmoneyService = this.createAirmoneyService();
+    }
+    createSimulatorService() {
+        const projectFolder = this.config.locationFolder
+            ? path_1.default.join(process.cwd(), this.config.locationFolder)
+            : process.cwd();
+        return this.config.appUrl
+            ? SimulatorService_1.SimulatorService.createWithProxy(this.config.appUrl, {
+                noBrowser: this.config.noBrowser,
+            })
+            : SimulatorService_1.SimulatorService.createWithProject(projectFolder, {
+                noBrowser: this.config.noBrowser,
+            });
+    }
+    createAirmoneyService() {
+        return new AirmoneyService_1.AirmoneyService({
+            port: 4040,
+            metadata: this.metadata ? { name: this.metadata.name } : undefined,
+        });
+    }
+    async start() {
+        // Check for port conflicts first
+        await PortManager_1.PortManager.checkPortConflicts();
+        // Validate metadata
+        if (!this.metadata) {
+            console.log('\x1b[33mNo metadata found. Skipping some possible checks.\x1b[0m');
+        }
+        // Start simulator service
+        await this.simulatorService.start();
+        // Connect simulator client to airmoney service
+        const simulatorClient = this.simulatorService.getClient();
+        if (simulatorClient) {
+            this.airmoneyService.setSimulatorClient(simulatorClient);
+        }
+        // Start airmoney service
+        await this.airmoneyService.start();
+        // Start crypto service
+        (0, cryptoProcess_1.startCryptoServiceSimple)();
+    }
+    async stop() {
+        await Promise.all([
+            this.simulatorService.stop(),
+            this.airmoneyService.stop(),
+        ]);
+    }
+}
+exports.ServeOrchestrator = ServeOrchestrator;

package/dist/service/serve/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/service/simulator/BaseSimulatorService.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseSimulatorService = void 0;
+const path_1 = __importDefault(require("path"));
+const express_1 = __importDefault(require("express"));
+const express_ws_1 = __importDefault(require("express-ws"));
+const cors_1 = __importDefault(require("cors"));
+const open_1 = __importDefault(require("open"));
+const http_proxy_middleware_1 = require("http-proxy-middleware");
+class BaseSimulatorService {
+    constructor(config) {
+        this.simulatorClient = null;
+        this.config = config;
+        this.app = (0, express_ws_1.default)((0, express_1.default)()).app;
+        this.setupMiddleware();
+    }
+    setupMiddleware() {
+        this.app.use((0, cors_1.default)());
+        this.app.use(express_1.default.json());
+    }
+    getSimulatorDir() {
+        // after tsc compile, serve.js is in dist/cli/
+        // we step up two dirs to get back to the project root
+        // then go into public/simulator
+        const base = path_1.default.resolve(__dirname, '..', '..', '..');
+        return path_1.default.join(base, 'public', 'simulator');
+    }
+    setupWebSocket() {
+        this.app.ws('/ws', (ws, req) => {
+            this.simulatorClient = ws;
+            ws.on('message', (msg) => {
+                console.log(msg);
+            });
+        });
+    }
+    setupStaticFiles() {
+        const simulatorDir = this.getSimulatorDir();
+        this.app.use('/simulator', express_1.default.static(simulatorDir));
+    }
+    setupProjectFiles() {
+        if (this.config.appUrl) {
+            const proxyMiddleware = (0, http_proxy_middleware_1.createProxyMiddleware)({
+                xfwd: true,
+                target: this.config.appUrl,
+                changeOrigin: true,
+                pathFilter: '/',
+            });
+            this.app.use('/', proxyMiddleware);
+        }
+        else if (this.config.projectFolder) {
+            this.app.use('/', express_1.default.static(this.config.projectFolder));
+        }
+    }
+    async openBrowser() {
+        if (!this.config.noBrowser) {
+            const url = `http://localhost:${this.config.port}/simulator`;
+            try {
+                await (0, open_1.default)(url);
+            }
+            catch (err) {
+                console.error('\x1b[31mFailed to open web browser\x1b[0m', err);
+            }
+        }
+    }
+    getClient() {
+        if (!this.simulatorClient)
+            return null;
+        return {
+            ws: this.simulatorClient,
+            send: (data) => {
+                if (this.simulatorClient) {
+                    this.simulatorClient.send(data);
+                }
+            },
+        };
+    }
+    sendToClient(data) {
+        if (this.simulatorClient) {
+            this.simulatorClient.send(data);
+            return true;
+        }
+        return false;
+    }
+    async start() {
+        this.setupWebSocket();
+        this.setupStaticFiles();
+        this.setupProjectFiles();
+        return new Promise(resolve => {
+            this.server = this.app.listen(this.config.port, () => {
+                const url = `http://localhost:${this.config.port}/simulator`;
+                console.log(`\x1b[32mStarting simulator server at ${url}\x1b[0m`);
+                this.openBrowser();
+                resolve();
+            });
+        });
+    }
+    async stop() {
+        return new Promise(resolve => {
+            if (this.server) {
+                this.server.close(() => {
+                    resolve();
+                });
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+}
+exports.BaseSimulatorService = BaseSimulatorService;

package/dist/service/simulator/SimulatorService.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimulatorService = void 0;
+const BaseSimulatorService_1 = require("./BaseSimulatorService");
+class SimulatorService extends BaseSimulatorService_1.BaseSimulatorService {
+    constructor(config) {
+        super(config);
+    }
+    /**
+     * Create a new SimulatorService instance with default configuration
+     */
+    static create(config = {}) {
+        const defaultConfig = {
+            port: 4041,
+            noBrowser: false,
+            ...config,
+        };
+        return new SimulatorService(defaultConfig);
+    }
+    /**
+     * Create a SimulatorService with project folder configuration
+     */
+    static createWithProject(projectFolder, config = {}) {
+        return SimulatorService.create({
+            projectFolder,
+            ...config,
+        });
+    }
+    /**
+     * Create a SimulatorService with app URL proxy configuration
+     */
+    static createWithProxy(appUrl, config = {}) {
+        return SimulatorService.create({
+            appUrl,
+            ...config,
+        });
+    }
+}
+exports.SimulatorService = SimulatorService;

package/dist/service/simulator/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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[33mError loading metadata\x1b[0m');
         return null;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@airmoney-degn/airmoney-cli",
-  "version": "0.12.2",
+  "version": "0.13.1",
   "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"