@airmoney-degn/airmoney-cli 0.24.1 → 0.25.1

package/dist/cli/build.js

@@ -41,12 +41,13 @@ const child_process_1 = require("child_process");
 const metadata_1 = require("../util/metadata");
 const tarball_1 = require("../util/tarball");
 const LogService_1 = require("../service/log/LogService");
-async function buildCommand({ locationFolder }) {
+async function buildCommand({ locationFolder, publicDir }) {
     const projectPath = locationFolder ? path.resolve(process.cwd(), locationFolder) : process.cwd();
     const meta = await (0, metadata_1.loadMetadata)(projectPath);
     if (!meta) {
         throw new Error('No metadata.json found.');
     }
+    (0, metadata_1.applyVersionFromCargoToml)(meta, projectPath);
     // Populate build metadata before building
     (0, LogService_1.log)('Populating build metadata...').white();
     (0, metadata_1.populateBuildMetadata)(meta, projectPath);
@@ -71,12 +72,10 @@ async function buildCommand({ locationFolder }) {
             cwd: projectPath,
             stdio: 'inherit',
         });
-        // 2. Find the binary
-        // Using standardized binary name "user_app" to match degn-launcher expectations
-        const binName = "user_app";
+        // 2. Find the binary (name from Cargo.toml [package] name)
+        const binName = (0, metadata_1.readPackageNameFromCargoToml)(projectPath) ?? 'user_app';
         const binPath = path.join(projectPath, 'target', 'aarch64-unknown-linux-gnu', 'release', binName);
         if (!fs.existsSync(binPath)) {
-            // Fallback: try to find any executable in the release folder if the name doesn't match exactly
             (0, LogService_1.log)(`Binary not found at expected path: ${binPath}`).white();
             throw new Error(`Could not find native binary for app: ${binName}`);
         }
@@ -91,8 +90,11 @@ async function buildCommand({ locationFolder }) {
             if (fs.existsSync(logoPath)) {
                 fs.copyFileSync(logoPath, path.join(tempDir, 'dapp-logo.png'));
             }
-            // Copy the binary as "user_app" for degn-launcher compatibility
-            fs.copyFileSync(binPath, path.join(tempDir, "user_app"));
+            fs.copyFileSync(binPath, path.join(tempDir, binName));
+            if (publicDir) {
+                const publicPath = path.join(projectPath, publicDir);
+                (0, tarball_1.copyDirContents)(publicPath, tempDir);
+            }
             // 4. Pack the project
             await (0, tarball_1.packProject)(meta, tempDir);
             (0, LogService_1.log)('Build and packaging complete!').green();

package/dist/cli/upload.js

@@ -60,12 +60,20 @@ function getProjectPath(locationFolder) {
     return path_1.default.join(process.cwd(), locationFolder);
 }
 /**
- * Prompts user for confirmation when uploading from current directory
+ * Prompts user for confirmation when uploading from current directory.
+ * Web: warns that all files from the directory will be packed/uploaded.
+ * Native: only mentions building and uploading the package (binary + metadata + logo).
  */
-async function confirmUploadFromCurrentDirectory(projectPath) {
-    (0, LogService_1.log)('⚠️  WARNING: You are about to upload all files from the current directory!').red();
-    (0, LogService_1.log)(`Upload folder: ${path_1.default.resolve(projectPath)}`).white();
-    (0, LogService_1.log)('To upload a specific folder, use: airmoney-cli upload -f <folder-path>').white();
+async function confirmUploadFromCurrentDirectory(projectPath, appType) {
+    if (appType === 'Native') {
+        (0, LogService_1.log)(`Upload folder: ${path_1.default.resolve(projectPath)}`).white();
+        (0, LogService_1.log)('A package (binary + metadata + logo) will be built and uploaded.').white();
+    }
+    else {
+        (0, LogService_1.log)('⚠️  WARNING: You are about to upload all files from the current directory!').red();
+        (0, LogService_1.log)(`Upload folder: ${path_1.default.resolve(projectPath)}`).white();
+        (0, LogService_1.log)('To upload a specific folder, use: airmoney-cli upload -f <folder-path>').white();
+    }
     const answer = await inquirer_1.default.prompt([
         {
             type: 'confirm',
@@ -119,30 +127,44 @@ async function calculateFileHash(filePath) {
 /**
  * Prepares the package by packing and reading it
  */
-async function preparePackage(meta, projectPath) {
+async function preparePackage(meta, projectPath, publicDir) {
     const pkgName = (0, metadata_1.getPackageName)(meta);
     if (meta.type === 'Native') {
         (0, LogService_1.log)(`Preparing Native package for ${meta.displayName}...`).white();
-        // 1. Find the binary
-        const binName = "user_app";
-        const binPath = path_1.default.join(projectPath, 'target', 'aarch64-unknown-linux-gnu', 'release', binName);
-        if (!fs.existsSync(binPath)) {
-            throw new Error('Native binary not found. Please run "airmoney-cli build" first to compile your application.');
+        const binName = (0, metadata_1.readPackageNameFromCargoToml)(projectPath) ?? 'user_app';
+        const binInTarget = path_1.default.join(projectPath, 'target', 'aarch64-unknown-linux-gnu', 'release', binName);
+        const binAtRoot = path_1.default.join(projectPath, binName);
+        const metadataAtRoot = path_1.default.join(projectPath, 'metadata.json');
+        const logoAtRoot = path_1.default.join(projectPath, 'dapp-logo.png');
+        // If folder already has binary + metadata + dapp-logo at root (e.g. dist/ or production/), zip the whole folder (includes all *.png and other assets)
+        if (fs.existsSync(binAtRoot) && fs.existsSync(metadataAtRoot) && fs.existsSync(logoAtRoot)) {
+            (0, LogService_1.log)(`Uploading folder as-is (binary and metadata at root; all files will be included).`).white();
+            (0, LogService_1.log)(`Packing ${pkgName}...`).white();
+            await (0, tarball_1.packProject)(meta, projectPath);
         }
-        // 2. Prepare packaging in a temp directory to avoid including target/ and other junk
-        const tempDir = fs.mkdtempSync(path_1.default.join(os.tmpdir(), 'airmoney-upload-'));
-        try {
-            fs.copyFileSync(path_1.default.join(projectPath, 'metadata.json'), path_1.default.join(tempDir, 'metadata.json'));
-            const logoPath = path_1.default.join(projectPath, 'dapp-logo.png');
-            if (fs.existsSync(logoPath)) {
-                fs.copyFileSync(logoPath, path_1.default.join(tempDir, 'dapp-logo.png'));
+        else if (fs.existsSync(binInTarget)) {
+            // Build layout: binary in target/; copy only metadata, logo, binary to avoid target/ and other junk
+            const tempDir = fs.mkdtempSync(path_1.default.join(os.tmpdir(), 'airmoney-upload-'));
+            try {
+                fs.copyFileSync(path_1.default.join(projectPath, 'metadata.json'), path_1.default.join(tempDir, 'metadata.json'));
+                const logoPath = path_1.default.join(projectPath, 'dapp-logo.png');
+                if (fs.existsSync(logoPath)) {
+                    fs.copyFileSync(logoPath, path_1.default.join(tempDir, 'dapp-logo.png'));
+                }
+                fs.copyFileSync(binInTarget, path_1.default.join(tempDir, binName));
+                if (publicDir) {
+                    const publicPath = path_1.default.join(projectPath, publicDir);
+                    (0, tarball_1.copyDirContents)(publicPath, tempDir);
+                }
+                (0, LogService_1.log)(`Packing ${pkgName}...`).white();
+                await (0, tarball_1.packProject)(meta, tempDir);
+            }
+            finally {
+                fs.rmSync(tempDir, { recursive: true, force: true });
             }
-            fs.copyFileSync(binPath, path_1.default.join(tempDir, "user_app"));
-            (0, LogService_1.log)(`Packing ${pkgName}...`).white();
-            await (0, tarball_1.packProject)(meta, tempDir);
         }
-        finally {
-            fs.rmSync(tempDir, { recursive: true, force: true });
+        else {
+            throw new Error(`Native binary not found. Either run "airmoney-cli build" first, or point -f to a folder that already contains ${binName}, metadata.json, and dapp-logo.png at root (e.g. dist/).`);
         }
     }
     else {
@@ -212,16 +234,55 @@ function cleanupPackageFile(pkgPath) {
 /**
  * Main upload command
  */
-async function uploadCommand({ network, locationFolder, }) {
+async function uploadCommand({ network, locationFolder, publicDir, packagePath: packagePathOpt, }) {
     let packageData = null;
+    let createdPackageByUs = false;
     try {
         const credentials = (0, env_1.validateCredential)();
         const { userId, apiKey, network } = credentials;
         (0, format_1.logUserAndNetwork)(userId, network);
+        if (packagePathOpt) {
+            // Upload an existing zip (e.g. output of airmoney-cli build)
+            const zipPath = path_1.default.isAbsolute(packagePathOpt)
+                ? packagePathOpt
+                : path_1.default.join(process.cwd(), packagePathOpt);
+            if (!fs.existsSync(zipPath) || !fs.statSync(zipPath).isFile()) {
+                throw new Error(`Package file not found: ${zipPath}`);
+            }
+            const projectPath = path_1.default.dirname(zipPath);
+            const meta = await (0, metadata_1.loadMetadata)(projectPath);
+            if (!meta) {
+                throw new Error(`No metadata.json found next to the package. Put metadata.json in the same directory as ${path_1.default.basename(zipPath)}.`);
+            }
+            (0, LogService_1.log)('Verifying zip package...').white();
+            const verifyOptions = meta.type === 'Native'
+                ? { binaryName: (0, metadata_1.readPackageNameFromCargoToml)(projectPath) ?? 'user_app' }
+                : undefined;
+            await (0, tarball_1.verifyZipPackage)(zipPath, meta.type, verifyOptions);
+            (0, LogService_1.log)('Zip package verified.').green();
+            const dappService = new DappService_1.DappService(userId, apiKey, network);
+            (0, LogService_1.log)(`Checking for existing versions of ${meta.name}...`).white();
+            const existingBuilds = await dappService.fetchDappVersions(meta.name);
+            const conflict = existingBuilds.find(b => b.version === meta.version);
+            if (conflict) {
+                (0, LogService_1.log)(`\nERROR: Version ${meta.version} already exists on the server.`).red();
+                (0, LogService_1.log)(`Status: ${conflict.status || 'Unknown'}`).red();
+                (0, LogService_1.log)(`Please bump your version and rebuild before uploading.`).yellow();
+                throw new Error(`Version conflict: ${meta.version} already exists.`);
+            }
+            const fileSize = fs.statSync(zipPath).size;
+            const fileHash = await calculateFileHash(zipPath);
+            (0, LogService_1.log)(`Package Hash: ${fileHash}`).white();
+            (0, LogService_1.log)(`Package Size: ${formatFileSize(fileSize)}`).white();
+            (0, LogService_1.log)('Publishing package to DEGN Dapp Store...').white();
+            await uploadPackageToServer(network || 'devnet', userId, apiKey, meta, zipPath, fileSize);
+            return;
+        }
         const projectPath = getProjectPath(locationFolder);
         // Prompt for confirmation if uploading from current directory
         if (!locationFolder) {
-            const confirmed = await confirmUploadFromCurrentDirectory(projectPath);
+            const metaForConfirm = await (0, metadata_1.loadMetadata)(projectPath);
+            const confirmed = await confirmUploadFromCurrentDirectory(projectPath, metaForConfirm?.type);
             if (!confirmed) {
                 (0, LogService_1.log)('Upload cancelled by user').yellow();
                 return;
@@ -231,6 +292,7 @@ async function uploadCommand({ network, locationFolder, }) {
             (0, LogService_1.log)(`Upload folder: ${path_1.default.resolve(projectPath)}`).white();
         }
         const meta = await loadAndValidateMetadata(locationFolder);
+        (0, metadata_1.applyVersionFromCargoToml)(meta, projectPath);
         // Version Conflict Check
         const dappService = new DappService_1.DappService(userId, apiKey, network);
         (0, LogService_1.log)(`Checking for existing versions of ${meta.name}...`).white();
@@ -246,7 +308,8 @@ async function uploadCommand({ network, locationFolder, }) {
         (0, LogService_1.log)('Populating build metadata...').white();
         (0, metadata_1.populateBuildMetadata)(meta, projectPath);
         (0, metadata_1.saveMetadata)(meta, projectPath);
-        packageData = await preparePackage(meta, projectPath);
+        packageData = await preparePackage(meta, projectPath, publicDir);
+        createdPackageByUs = true;
         (0, LogService_1.log)('Publishing package to DEGN Dapp Store...').white();
         await uploadPackageToServer(network || "devnet", userId, apiKey, meta, packageData.pkgPath, packageData.fileSize);
     }
@@ -256,8 +319,7 @@ async function uploadCommand({ network, locationFolder, }) {
         throw err;
     }
     finally {
-        // Clean up package file if it was created
-        if (packageData) {
+        if (createdPackageByUs && packageData) {
             cleanupPackageFile(packageData.pkgPath);
         }
     }

package/dist/config.json

@@ -1,3 +1,3 @@
 {
-    "version": "0.24.1"
+    "version": "0.25.1"
 }

package/dist/index.js

@@ -54,10 +54,11 @@ program
     .command('build')
     .description('Build and package the project')
     .option('-f, --app-path <string>', 'path to the project')
+    .option('--public-dir <string>', 'folder whose contents are bundled as static assets (default: public)', 'public')
     .action(async (opts) => {
     try {
-        const { appPath } = opts;
-        await (0, build_1.buildCommand)({ locationFolder: appPath });
+        const { appPath, publicDir } = opts;
+        await (0, build_1.buildCommand)({ locationFolder: appPath, publicDir });
     }
     catch (err) {
         process.exit(1);
@@ -134,8 +135,10 @@ program
     .description('Publish the app to the DEGN Dapp Store')
     .option('-n, --network <string>', 'network devnet|mainnet')
     .option('-f, --index-app-path <string>', 'path for the index.html', './')
+    .option('-p, --package <path>', 'path to existing zip (e.g. output of build); upload this file and skip re-packing')
+    .option('--public-dir <string>', 'folder whose contents are bundled as static assets (default: public)', 'public')
     .action(async (opts) => {
-    let { network, indexAppPath } = opts;
+    let { network, indexAppPath, package: packagePath, publicDir } = opts;
     if (indexAppPath == './') {
         indexAppPath = undefined;
     }
@@ -143,6 +146,8 @@ program
         await (0, upload_1.uploadCommand)({
             network,
             locationFolder: indexAppPath,
+            publicDir,
+            packagePath,
         });
     }
     catch (err) {

package/dist/util/metadata.js

@@ -32,13 +32,20 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadMetadata = loadMetadata;
 exports.saveMetadata = saveMetadata;
 exports.getPackageName = getPackageName;
+exports.readPackageNameFromCargoToml = readPackageNameFromCargoToml;
+exports.readVersionFromCargoToml = readVersionFromCargoToml;
+exports.applyVersionFromCargoToml = applyVersionFromCargoToml;
 exports.populateBuildMetadata = populateBuildMetadata;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const toml_1 = __importDefault(require("toml"));
 const LogService_1 = require("../service/log/LogService");
 const child_process_1 = require("child_process");
 const remote_1 = require("./remote");
@@ -87,14 +94,75 @@ function getPackageName(pkg) {
     // e.g. myApp-0.1.0.zip
     return `${pkg.name}-${pkg.version}.zip`;
 }
+function parseCargoToml(projectPath) {
+    const cargoPath = path.join(projectPath, 'Cargo.toml');
+    if (!fs.existsSync(cargoPath)) {
+        return null;
+    }
+    try {
+        const content = fs.readFileSync(cargoPath, 'utf8');
+        return toml_1.default.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Reads the package name from Cargo.toml [package] section (used as binary name).
+ * Returns null if file is missing or name is not found.
+ */
+function readPackageNameFromCargoToml(projectPath) {
+    const parsed = parseCargoToml(projectPath);
+    const name = parsed?.package?.name;
+    return typeof name === 'string' ? name : null;
+}
+/**
+ * Reads the package version from Cargo.toml [package] section.
+ * Returns null if file is missing or version is not found.
+ */
+function readVersionFromCargoToml(projectPath) {
+    const parsed = parseCargoToml(projectPath);
+    const version = parsed?.package?.version;
+    return typeof version === 'string' ? version : null;
+}
+/**
+ * For Native projects, reads version from Cargo.toml, sets meta.version, and saves metadata.json.
+ * No-op for Web or when Cargo.toml is missing / has no version.
+ */
+function applyVersionFromCargoToml(meta, projectPath) {
+    if (meta.type !== 'Native') {
+        return;
+    }
+    const versionFromCargo = readVersionFromCargoToml(projectPath);
+    if (versionFromCargo) {
+        meta.version = versionFromCargo;
+        saveMetadata(meta, projectPath);
+    }
+}
 function populateBuildMetadata(pkg, projectPath) {
-    // 1. Build Number: Increment if numeric, or use timestamp
-    const currentBuild = parseInt(pkg.buildNumber || '0', 10);
-    if (!isNaN(currentBuild)) {
-        pkg.buildNumber = (currentBuild + 1).toString();
+    // 1. Build Number: use git rev-list --count HEAD; on failure fall back to increment or timestamp
+    try {
+        const count = (0, child_process_1.execSync)('git rev-list --count HEAD', {
+            cwd: projectPath,
+            stdio: ['ignore', 'pipe', 'ignore'],
+            encoding: 'utf8',
+        })
+            .trim();
+        if (count !== '') {
+            pkg.buildNumber = count;
+        }
+        else {
+            throw new Error('empty');
+        }
     }
-    else {
-        pkg.buildNumber = Math.floor(Date.now() / 1000).toString();
+    catch {
+        const currentBuild = parseInt(pkg.buildNumber || '0', 10);
+        if (!isNaN(currentBuild)) {
+            pkg.buildNumber = (currentBuild + 1).toString();
+        }
+        else {
+            pkg.buildNumber = Math.floor(Date.now() / 1000).toString();
+        }
     }
     // 2. Commit Hash
     try {

package/dist/util/tarball.js

@@ -36,15 +36,93 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyZipPackage = verifyZipPackage;
+exports.copyDirContents = copyDirContents;
 exports.packProject = packProject;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const crypto = __importStar(require("crypto"));
 const archiver_1 = __importDefault(require("archiver"));
+const yauzl_1 = __importDefault(require("yauzl"));
 const metadata_1 = require("./metadata");
 const LogService_1 = require("../service/log/LogService");
 const REQUIRED_FILES_WEB = ['metadata.json', 'dapp-logo.png', 'index.html'];
 const REQUIRED_FILES_NATIVE = ['metadata.json', 'dapp-logo.png'];
+/**
+ * Returns entry file names in the zip (directories excluded; names may include path).
+ */
+function getZipEntryNames(zipPath) {
+    return new Promise((resolve, reject) => {
+        yauzl_1.default.open(zipPath, { lazyEntries: true }, (err, zipfile) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            const names = [];
+            zipfile.on('entry', (entry) => {
+                if (!/\/$/.test(entry.fileName)) {
+                    names.push(entry.fileName);
+                }
+                zipfile.readEntry();
+            });
+            zipfile.on('end', () => {
+                zipfile.close();
+                resolve(names);
+            });
+            zipfile.readEntry();
+        });
+    });
+}
+/**
+ * Verifies the zip is valid and contains required files for the given package type.
+ * For Native, also verifies the binary file is present when binaryName is provided.
+ * @throws Error if the zip is invalid or missing required files
+ */
+async function verifyZipPackage(zipPath, type, options) {
+    const required = type === 'Native' ? REQUIRED_FILES_NATIVE : REQUIRED_FILES_WEB;
+    let names;
+    try {
+        names = await getZipEntryNames(zipPath);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(`Invalid or corrupt zip file: ${msg}`);
+    }
+    const hasFile = (name) => names.some(n => n === name || n.endsWith('/' + name));
+    const missing = required.filter(r => !hasFile(r));
+    if (missing.length > 0) {
+        throw new Error(`Zip is missing required files: ${missing.join(', ')}. Required for ${type}: ${required.join(', ')}.`);
+    }
+    if (type === 'Native' && options?.binaryName) {
+        if (!hasFile(options.binaryName)) {
+            throw new Error(`Zip is missing Native binary: ${options.binaryName}. Required for Native packages.`);
+        }
+    }
+}
+/**
+ * Copies the contents of srcDir into destDir (merge; destDir gets srcDir's files/subdirs at root).
+ */
+function copyDirContents(srcDir, destDir) {
+    if (!fs.existsSync(srcDir)) {
+        return;
+    }
+    const stat = fs.statSync(srcDir);
+    if (!stat.isDirectory()) {
+        return;
+    }
+    const entries = fs.readdirSync(srcDir, { withFileTypes: true });
+    for (const e of entries) {
+        const src = path.join(srcDir, e.name);
+        const dest = path.join(destDir, e.name);
+        if (e.isDirectory()) {
+            fs.mkdirSync(dest, { recursive: true });
+            copyDirContents(src, dest);
+        }
+        else {
+            fs.copyFileSync(src, dest);
+        }
+    }
+}
 /**
  * Validates that the project path exists
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@airmoney-degn/airmoney-cli",
-  "version": "0.24.1",
+  "version": "0.25.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"
@@ -50,8 +50,10 @@
     "node-fetch": "^2.6.7",
     "open": "^8.4.0",
     "tar": "^6.1.13",
+    "toml": "^3.0.0",
     "websocket": "^1.0.35",
-    "ws": "^8.18.1"
+    "ws": "^8.18.1",
+    "yauzl": "^3.2.0"
   },
   "devDependencies": {
     "@airmoney-degn/controller-sdk": "^5.4.1",
@@ -67,6 +69,7 @@
     "@types/node-fetch": "^2.6.12",
     "@types/tar": "^6.1.13",
     "@types/websocket": "^1.0.10",
+    "@types/yauzl": "^2.10.3",
     "prettier": "^3.6.1",
     "typescript": "^5.0.4"
   },