@airmoney-degn/airmoney-cli 0.23.0 → 0.24.0

package/dist/cli/build.js

@@ -0,0 +1,109 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCommand = buildCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+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 }) {
+    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.');
+    }
+    // Populate build metadata before building
+    (0, LogService_1.log)('Populating build metadata...').white();
+    (0, metadata_1.populateBuildMetadata)(meta, projectPath);
+    (0, metadata_1.saveMetadata)(meta, projectPath);
+    if (meta.type !== 'Native') {
+        (0, LogService_1.log)('Build is only required for Native (Rust) applications. For Web apps, use your preferred build tool (e.g., npm run build).').white();
+        return;
+    }
+    // Early validation of required assets
+    const requiredAssets = ['dapp-logo.png'];
+    for (const asset of requiredAssets) {
+        if (!fs.existsSync(path.join(projectPath, asset))) {
+            throw new Error(`Missing required asset: ${asset}. Please ensure it exists at the root of your project.`);
+        }
+    }
+    (0, LogService_1.log)(`Building native application: ${meta.displayName}...`).white();
+    try {
+        // 1. Run cross build
+        (0, LogService_1.log)('Executing cross build for aarch64-unknown-linux-gnu...').white();
+        // Ensure we are in the project directory for the exec call
+        (0, child_process_1.execSync)('cross build --target aarch64-unknown-linux-gnu --release', {
+            cwd: projectPath,
+            stdio: 'inherit',
+        });
+        // 2. Find the binary
+        // Using standardized binary name "user_app" to match degn-launcher expectations
+        const binName = "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}`);
+        }
+        (0, LogService_1.log)(`Native binary found: ${binPath}`).green();
+        // 3. Prepare packaging in a temp directory
+        (0, LogService_1.log)('Preparing package...').white();
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'airmoney-build-'));
+        try {
+            // Copy required files to temp dir
+            fs.copyFileSync(path.join(projectPath, 'metadata.json'), path.join(tempDir, 'metadata.json'));
+            const logoPath = path.join(projectPath, 'dapp-logo.png');
+            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"));
+            // 4. Pack the project
+            await (0, tarball_1.packProject)(meta, tempDir);
+            (0, LogService_1.log)('Build and packaging complete!').green();
+        }
+        finally {
+            // Cleanup temp dir
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        }
+    }
+    catch (err) {
+        (0, LogService_1.log)(`Build failed: ${err.message}`).red();
+        throw err;
+    }
+}

package/dist/cli/create.js

@@ -32,21 +32,95 @@ 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.createCommand = createCommand;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
+const inquirer_1 = __importDefault(require("inquirer"));
 const types_1 = require("../types");
 const child_process_1 = require("child_process");
 const LogService_1 = require("../service/log/LogService");
+const env_1 = require("../util/env");
+const DappService_1 = require("../service/dapp/DappService");
 async function createCommand({ name, template, locationFolder, quiet, }) {
     try {
+        const questions = [
+            {
+                type: 'input',
+                name: 'displayName',
+                message: 'Display Name:',
+                default: name,
+                validate: (input) => input.trim() !== '' || 'Display Name is required',
+            },
+            {
+                type: 'input',
+                name: 'description',
+                message: 'Description:',
+                validate: (input) => input.trim() !== '' || 'Description is required',
+            },
+            {
+                type: 'input',
+                name: 'author',
+                message: 'Author:',
+                validate: (input) => input.trim() !== '' || 'Author is required',
+            },
+            {
+                type: 'list',
+                name: 'type',
+                message: 'App Type:',
+                choices: [
+                    { name: 'Web (Standard)', value: 'Web' },
+                    { name: 'Native (Rust/Slint) - Experimental', value: 'Native' },
+                ],
+                default: 'Web',
+            },
+            {
+                type: 'input',
+                name: 'version',
+                message: 'Version:',
+                default: '0.0.1',
+            },
+        ];
+        const answers = await inquirer_1.default.prompt(questions);
         const identifier = `com.degn.${name}`;
-        (0, LogService_1.log)(`Initializing project: ${name}`).white();
+        (0, LogService_1.log)(`Initializing project: ${name} [${answers.type}]`).white();
+        // Duplicate Check
+        try {
+            const { userId, apiKey, network } = (0, env_1.validateCredential)();
+            const dappService = new DappService_1.DappService(userId, apiKey, network);
+            const isAvailable = await dappService.checkDappName(identifier);
+            if (!isAvailable) {
+                (0, LogService_1.log)(`\nWARNING: The identifier '${identifier}' is already registered on-chain.`).red();
+                (0, LogService_1.log)(`You may not be able to publish this DApp unless you own it.`).red();
+                const { proceed } = await inquirer_1.default.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'proceed',
+                        message: 'Do you want to proceed anyway?',
+                        default: false,
+                    },
+                ]);
+                if (!proceed) {
+                    (0, LogService_1.log)('Aborting project creation.').yellow();
+                    return;
+                }
+            }
+        }
+        catch (err) {
+            // If credentials aren't setup, we can't check, so we just proceed with a warning
+            (0, LogService_1.log)('Notice: Could not verify identifier availability (credentials not found).').yellow();
+        }
         const folderName = locationFolder || name;
         const projectPath = path.join(process.cwd(), folderName);
         if (template) {
+            // ... (existing template clone logic)
+            // Note: Templates are currently Web-only.
+            // If user selected Native but used --template, we might want to warn or handle it.
+            // For now, let's assume template flag overrides the scaffolding.
             (0, LogService_1.log)('cloning project').white();
             const tempGitDir = path.join(os.tmpdir(), `airmoney-git-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`);
             // Clean up if it already exists (shouldn't happen, but just in case)
@@ -72,8 +146,122 @@ async function createCommand({ name, template, locationFolder, quiet, }) {
         }
         else {
             fs.mkdirSync(projectPath, { recursive: true });
-            // replicate Rust logic
-            const indexHtml = `
+            if (answers.type === 'Native') {
+                // Native Rust/Slint Scaffolding
+                // Cargo.toml
+                const cargoToml = `[package]
+name = "user_app"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+slint = "1.0.0"
+
+[workspace]
+`;
+                fs.writeFileSync(path.join(projectPath, 'Cargo.toml'), cargoToml, 'utf8');
+                // src/main.rs
+                const srcDir = path.join(projectPath, 'src');
+                fs.mkdirSync(srcDir, { recursive: true });
+                const mainRs = `slint::slint! {
+    export component MainWindow inherits Window {
+        callback close_app();
+        VerticalLayout {
+            alignment: center;
+            Text {
+                text: "Hello from ${name} (Native)";
+                color: green;
+                horizontal-alignment: center;
+            }
+            Rectangle {
+                height: 50px;
+                width: 150px;
+                background: red;
+                border-radius: 4px;
+                TouchArea {
+                    clicked => { root.close_app(); }
+                }
+                Text {
+                    text: "Close App";
+                    color: white;
+                    x: (parent.width - self.width) / 2;
+                    y: (parent.height - self.height) / 2;
+                }
+            }
+        }
+    }
+}
+
+fn main() {
+    let main_window = MainWindow::new().unwrap();
+    main_window.window().set_fullscreen(true);
+    
+    let weak_window = main_window.as_weak();
+    main_window.on_close_app(move || {
+        // Call degn-launcher to close this app
+        // We use a simple TCP connection to avoid adding reqwest dependency for just this
+        if let Ok(mut stream) = std::net::TcpStream::connect("127.0.0.1:7070") {
+            use std::io::Write;
+            let _ = stream.write_all(b"POST /close HTTP/1.1\\r\\nHost: localhost\\r\\n\\r\\n");
+        } else {
+             eprintln!("Failed to connect to launcher control server");
+             std::process::exit(0);
+        }
+    });
+
+    main_window.run().unwrap();
+}
+`;
+                fs.writeFileSync(path.join(srcDir, 'main.rs'), mainRs, 'utf8');
+                // .gitignore
+                fs.writeFileSync(path.join(projectPath, '.gitignore'), '/target\n', 'utf8');
+                // Cross.toml
+                const crossToml = `[target.aarch64-unknown-linux-gnu]
+dockerfile = "./cross/Dockerfile"
+
+[target.aarch64-unknown-linux-gnu.env]
+PASSTHROUGH = ["PKG_CONFIG_ALLOW_CROSS"]
+
+[build]
+docker-default-platform = "linux/amd64"
+`;
+                fs.writeFileSync(path.join(projectPath, 'Cross.toml'), crossToml, 'utf8');
+                // cross/Dockerfile
+                const crossDir = path.join(projectPath, 'cross');
+                fs.mkdirSync(crossDir, { recursive: true });
+                const dockerfile = `FROM --platform=linux/amd64 ubuntu:22.04
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+RUN apt-get update && apt-get install -y \\
+    build-essential \\
+    gcc-aarch64-linux-gnu \\
+    libc6-dev-arm64-cross \\
+    curl \\
+    git \\
+    pkg-config \\
+    cmake \\
+    libwayland-dev \\
+    libxkbcommon-dev \\
+    libfontconfig1-dev \\
+    libssl-dev \\
+    && rm -rf /var/lib/apt/lists/*
+
+RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
+ENV PATH="/root/.cargo/bin:\${PATH}"
+
+RUN rustup target add aarch64-unknown-linux-gnu
+
+ENV PKG_CONFIG_ALLOW_CROSS=1
+ENV TARGET_CC=aarch64-linux-gnu-gcc
+ENV CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER=aarch64-linux-gnu-gcc
+`;
+                fs.writeFileSync(path.join(crossDir, 'Dockerfile'), dockerfile, 'utf8');
+            }
+            else {
+                // Web Scaffolding
+                // replicate Rust logic
+                const indexHtml = `
 <html>
 <head>
   <title>Sample ${name}</title>
@@ -83,17 +271,28 @@ async function createCommand({ name, template, locationFolder, quiet, }) {
 </body>
 </html>
 `.trim();
-            fs.writeFileSync(path.join(projectPath, 'index.html'), indexHtml, 'utf8');
-            // assets
-            const assetsDir = path.join(projectPath, 'assets');
-            fs.mkdirSync(assetsDir, { recursive: true });
-            fs.writeFileSync(path.join(assetsDir, 'main.js'), '// sample main.js\n', 'utf8');
-            fs.writeFileSync(path.join(assetsDir, 'style.css'), '/* sample style.css */\n', 'utf8');
+                fs.writeFileSync(path.join(projectPath, 'index.html'), indexHtml, 'utf8');
+                // assets
+                const assetsDir = path.join(projectPath, 'assets');
+                fs.mkdirSync(assetsDir, { recursive: true });
+                fs.writeFileSync(path.join(assetsDir, 'main.js'), '// sample main.js\n', 'utf8');
+                fs.writeFileSync(path.join(assetsDir, 'style.css'), '/* sample style.css */\n', 'utf8');
+            }
         }
         // metadata
         const pkg = (0, types_1.createPackage)(name, identifier);
+        pkg.displayName = answers.displayName;
+        pkg.description = answers.description;
+        pkg.author = answers.author;
+        pkg.version = answers.version;
+        pkg.type = answers.type;
+        pkg.maintainer = answers.author; // Default maintainer to author
         const metaStr = JSON.stringify(pkg, null, 2);
         fs.writeFileSync(path.join(projectPath, 'metadata.json'), metaStr, 'utf8');
+        // Create a default placeholder logo
+        const placeholderLogoBase64 = 'iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAACXBIWXMAAAsTAAALEwEAmpwYAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAuSURBVHgB7cExAQAAAMKg9U9tCj8gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALwCReAAAd7O664AAAAASUVORK5CYII=';
+        const logoBuffer = Buffer.from(placeholderLogoBase64, 'base64');
+        fs.writeFileSync(path.join(projectPath, 'dapp-logo.png'), logoBuffer);
         (0, LogService_1.log)(`Project '${name}' created successfully.`).green();
         if (!quiet) {
             (0, LogService_1.log)(`\nNext steps:`).white();
@@ -107,6 +306,10 @@ async function createCommand({ name, template, locationFolder, quiet, }) {
                 (0, LogService_1.log)('  npm run build').white();
                 (0, LogService_1.log)('  airmoney-cli serve -f dist').white();
             }
+            else if (answers.type === 'Native') {
+                (0, LogService_1.log)('  cargo run').white();
+                (0, LogService_1.log)('  # To build for device, ensure you have the correct target installed.').white();
+            }
             else {
                 (0, LogService_1.log)('  airmoney-cli serve').white();
             }

package/dist/cli/upload.js

@@ -38,15 +38,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.uploadCommand = uploadCommand;
 const fs = __importStar(require("fs"));
+const crypto = __importStar(require("crypto"));
 const node_fetch_1 = __importDefault(require("node-fetch"));
-const md5_1 = __importDefault(require("md5"));
 const path_1 = __importDefault(require("path"));
-const inquirer_1 = __importDefault(require("inquirer"));
 const metadata_1 = require("../util/metadata");
 const tarball_1 = require("../util/tarball");
 const network_1 = require("../util/network");
 const env_1 = require("../util/env");
 const LogService_1 = require("../service/log/LogService");
+const DappService_1 = require("../service/dapp/DappService");
+const os = __importStar(require("os"));
+const inquirer_1 = __importDefault(require("inquirer"));
 const format_1 = require("../util/format");
 /**
  * Gets the project path based on location folder
@@ -100,23 +102,63 @@ function formatFileSize(bytes) {
     }
     return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
 }
+/**
+ * Calculates the MD5 hash of a file using streams to avoid OOM
+ */
+async function calculateFileHash(filePath) {
+    return new Promise((resolve, reject) => {
+        const hash = crypto.createHash('md5');
+        const input = fs.createReadStream(filePath);
+        input.on('error', reject);
+        input.on('data', chunk => hash.update(chunk));
+        input.on('end', () => {
+            resolve(hash.digest('hex'));
+        });
+    });
+}
 /**
  * Prepares the package by packing and reading it
  */
 async function preparePackage(meta, projectPath) {
     const pkgName = (0, metadata_1.getPackageName)(meta);
-    (0, LogService_1.log)(`Packing ${pkgName}...`).white();
-    await (0, tarball_1.packProject)(meta, projectPath);
+    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.');
+        }
+        // 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'));
+            }
+            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 {
+        (0, LogService_1.log)(`Packing Web package ${pkgName}...`).white();
+        await (0, tarball_1.packProject)(meta, projectPath);
+    }
     const pkgPath = path_1.default.join(process.cwd(), pkgName);
-    if (!fs.existsSync(pkgPath)) {
+    const stats = fs.statSync(pkgPath);
+    if (!stats.isFile()) {
         throw new Error(`Package file not found at ${pkgPath}`);
     }
-    const fileBuffer = fs.readFileSync(pkgPath);
-    const fileHash = (0, md5_1.default)(fileBuffer);
-    const fileSize = fileBuffer.length;
+    const fileHash = await calculateFileHash(pkgPath);
+    const fileSize = stats.size;
     (0, LogService_1.log)(`Package Hash: ${fileHash}`).white();
     (0, LogService_1.log)(`Package Size: ${formatFileSize(fileSize)}`).white();
-    return { fileBuffer, fileHash, pkgPath };
+    return { fileHash, pkgPath, fileSize };
 }
 /**
  * Creates the JSON-RPC request body for upload
@@ -129,16 +171,17 @@ async function preparePackage(meta, projectPath) {
 /**
  * Uploads the package to the server
  */
-async function uploadPackageToServer(network, userId, apiKey, meta, fileBuffer) {
+async function uploadPackageToServer(network, userId, apiKey, meta, pkgPath, fileSize) {
     const origin = (0, network_1.networkToRpcUrl)(network).replace(/\/+$/, '');
     const metaParam = encodeURIComponent(JSON.stringify(meta));
     const url = `${origin}/upload?user=${userId}&apiKey=${apiKey}&meta=${metaParam}`;
     const res = await (0, node_fetch_1.default)(url, {
         method: 'POST',
-        // raw bytes, no base64 overhead
-        body: fileBuffer,
+        // Stream the file directly from disk
+        body: fs.createReadStream(pkgPath),
         headers: {
             'Content-Type': 'application/octet-stream',
+            'Content-Length': fileSize.toString(),
         },
     });
     const text = await res.text();
@@ -184,9 +227,24 @@ async function uploadCommand({ network, locationFolder, }) {
             (0, LogService_1.log)(`Upload folder: ${path_1.default.resolve(projectPath)}`).white();
         }
         const meta = await loadAndValidateMetadata(locationFolder);
+        // Version Conflict Check
+        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 in metadata.json before uploading.`).yellow();
+            throw new Error(`Version conflict: ${meta.version} already exists.`);
+        }
+        // Populate build metadata before upload/packaging
+        (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);
         (0, LogService_1.log)('Publishing package to DEGN Dapp Store...').white();
-        await uploadPackageToServer(network || "devnet", userId, apiKey, meta, packageData.fileBuffer);
+        await uploadPackageToServer(network || "devnet", userId, apiKey, meta, packageData.pkgPath, packageData.fileSize);
     }
     catch (err) {
         const errorMessage = err instanceof Error ? err.message : String(err);

package/dist/config.json

@@ -1,3 +1,3 @@
 {
-    "version": "0.23.0"
+    "version": "0.24.0"
 }

package/dist/index.js

@@ -5,6 +5,7 @@ const commander_1 = require("commander");
 const demo_1 = require("./cli/demo");
 const env_1 = require("./util/env");
 const create_1 = require("./cli/create");
+const build_1 = require("./cli/build");
 const serve_1 = require("./cli/serve");
 const upload_1 = require("./cli/upload");
 const setup_1 = require("./cli/setup");
@@ -49,6 +50,19 @@ program
         process.exit(1);
     }
 });
+program
+    .command('build')
+    .description('Build and package the project')
+    .option('-f, --app-path <string>', 'path to the project')
+    .action(async (opts) => {
+    try {
+        const { appPath } = opts;
+        await (0, build_1.buildCommand)({ locationFolder: appPath });
+    }
+    catch (err) {
+        process.exit(1);
+    }
+});
 program
     .command('serve')
     .description('Serve locally in the simulator')

package/dist/service/dapp/DappService.js

@@ -87,6 +87,12 @@ class DappService {
     async validateApiKey() {
         return await this.makeJsonRpcRequest('checkApiKey', [this.userId, this.apiKey]);
     }
+    /**
+     * Checks if a dapp name (identifier) is available
+     */
+    async checkDappName(name) {
+        return await this.makeJsonRpcRequest('checkDappName', [this.userId, this.apiKey, name]);
+    }
     /**
      * Fetches dapp list from API
      */

package/dist/service/log/LogService.js

@@ -43,17 +43,17 @@ class LogBuilder {
         this.execute();
     }
     /**
-     * Sets the color to white and logs
+     * Sets the color to yellow and logs
      */
-    white() {
-        this.color = 'white';
+    yellow() {
+        this.color = 'yellow';
         this.execute();
     }
     /**
-     * Sets the color to yellow and logs
+     * Sets the color to white and logs
      */
-    yellow() {
-        this.color = 'yellow';
+    white() {
+        this.color = 'white';
         this.execute();
     }
     /**

package/dist/types.js

@@ -8,6 +8,8 @@ function createPackage(name, identifier) {
         displayName: '',
         author: '',
         maintainer: '',
+        description: '',
+        type: 'Web',
         url: '',
         themeColor: '',
         version: '0.0.1',

package/dist/util/metadata.js

@@ -36,9 +36,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadMetadata = loadMetadata;
 exports.saveMetadata = saveMetadata;
 exports.getPackageName = getPackageName;
+exports.populateBuildMetadata = populateBuildMetadata;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const LogService_1 = require("../service/log/LogService");
+const child_process_1 = require("child_process");
 const remote_1 = require("./remote");
 async function loadMetadata(projectPath = '.', appUrl) {
     try {
@@ -82,6 +84,34 @@ function saveMetadata(pkg, projectPath = '.') {
     fs.writeFileSync(filePath, JSON.stringify(pkg, null, 2), 'utf8');
 }
 function getPackageName(pkg) {
-    // e.g. com.degn.myApp-0.1.0.tar.gz
-    return `${pkg.identifier}-${pkg.version}.tar.gz`;
+    // e.g. myApp-0.1.0.zip
+    return `${pkg.name}-${pkg.version}.zip`;
+}
+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();
+    }
+    else {
+        pkg.buildNumber = Math.floor(Date.now() / 1000).toString();
+    }
+    // 2. Commit Hash
+    try {
+        const hash = (0, child_process_1.execSync)('git rev-parse HEAD', { cwd: projectPath, stdio: ['ignore', 'pipe', 'ignore'] })
+            .toString()
+            .trim();
+        pkg.commitHash = hash;
+    }
+    catch (err) {
+        pkg.commitHash = 'n/a';
+    }
+    // 3. Build Date: YYYYMMDD-HHmm (local)
+    const now = new Date();
+    const year = now.getFullYear();
+    const month = String(now.getMonth() + 1).padStart(2, '0');
+    const day = String(now.getDate()).padStart(2, '0');
+    const hours = String(now.getHours()).padStart(2, '0');
+    const minutes = String(now.getMinutes()).padStart(2, '0');
+    pkg.buildDate = `${year}${month}${day}-${hours}${minutes}`;
 }

package/dist/util/tarball.js

@@ -39,11 +39,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.packProject = packProject;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const tar = __importStar(require("tar"));
-const md5_1 = __importDefault(require("md5"));
+const crypto = __importStar(require("crypto"));
+const archiver_1 = __importDefault(require("archiver"));
 const metadata_1 = require("./metadata");
 const LogService_1 = require("../service/log/LogService");
-const REQUIRED_FILES = ['metadata.json', 'dapp-logo.png', 'index.html'];
+const REQUIRED_FILES_WEB = ['metadata.json', 'dapp-logo.png', 'index.html'];
+const REQUIRED_FILES_NATIVE = ['metadata.json', 'dapp-logo.png'];
 /**
  * Validates that the project path exists
  */
@@ -55,9 +56,10 @@ function validateProjectPath(projectPath) {
 /**
  * Validates that all required files exist at the root of the project
  */
-function validateRequiredFiles(projectPath) {
+function validateRequiredFiles(projectPath, pkg) {
     const missingFiles = [];
-    REQUIRED_FILES.forEach(file => {
+    const required = pkg.type === 'Native' ? REQUIRED_FILES_NATIVE : REQUIRED_FILES_WEB;
+    required.forEach(file => {
         const filePath = path.join(projectPath, file);
         if (!fs.existsSync(filePath)) {
             missingFiles.push(file);
@@ -68,78 +70,77 @@ function validateRequiredFiles(projectPath) {
     }
 }
 /**
- * Recursively gets all files from a directory
+ * Creates the zip file
  */
-function getAllFiles(dir, baseDir, fileList = []) {
-    const items = fs.readdirSync(dir);
-    items.forEach(item => {
-        const fullPath = path.join(dir, item);
-        const stat = fs.statSync(fullPath);
-        if (stat.isDirectory()) {
-            getAllFiles(fullPath, baseDir, fileList);
-        }
-        else {
-            const relativePath = path.relative(baseDir, fullPath);
-            fileList.push(relativePath);
-        }
-    });
-    return fileList;
-}
-/**
- * Collects all files from the project directory
- */
-function collectProjectFiles(projectPath) {
-    const allFiles = getAllFiles(projectPath, projectPath);
-    if (allFiles.length === 0) {
-        throw new Error(`No files found in ${projectPath}`);
-    }
-    return allFiles;
-}
-/**
- * Creates the tarball file
- */
-async function createTarball(outputPath, projectPath, files) {
+async function createZip(outputPath, projectPath) {
     // Clean up any existing output file
     if (fs.existsSync(outputPath)) {
         fs.rmSync(outputPath);
     }
-    await tar.create({
-        file: outputPath,
-        gzip: true,
-        cwd: projectPath,
-        prefix: '',
-        portable: true,
-    }, files);
-    if (!fs.existsSync(outputPath)) {
-        throw new Error('Tarball was not created successfully');
-    }
+    return new Promise((resolve, reject) => {
+        const output = fs.createWriteStream(outputPath);
+        const archive = (0, archiver_1.default)('zip', {
+            zlib: { level: 9 } // Sets the compression level.
+        });
+        output.on('close', function () {
+            resolve();
+        });
+        archive.on('warning', function (err) {
+            if (err.code === 'ENOENT') {
+                // log warning
+            }
+            else {
+                reject(err);
+            }
+        });
+        archive.on('error', function (err) {
+            reject(err);
+        });
+        archive.pipe(output);
+        // append files from a directory, putting its contents at the root of archive
+        // ignore common junk files
+        archive.directory(projectPath, false, (data) => {
+            const ignoredFolders = ['node_modules', '.git', 'target', '.DS_Store'];
+            if (ignoredFolders.some(folder => data.name.startsWith(folder))) {
+                return false;
+            }
+            return data;
+        });
+        archive.finalize();
+    });
 }
 /**
- * Calculates and logs the MD5 hash of the tarball
+ * Calculates and logs the MD5 hash of the zip using streams to avoid OOM
  */
-function logTarballHash(outputPath) {
-    const buffer = fs.readFileSync(outputPath);
-    const digest = (0, md5_1.default)(buffer);
-    (0, LogService_1.log)(`MD5: ${digest}`).white();
+async function logPackageHash(outputPath) {
+    return new Promise((resolve, reject) => {
+        const hash = crypto.createHash('md5');
+        const input = fs.createReadStream(outputPath);
+        input.on('error', reject);
+        input.on('data', chunk => hash.update(chunk));
+        input.on('end', () => {
+            const digest = hash.digest('hex');
+            (0, LogService_1.log)(`MD5: ${digest}`).white();
+            resolve();
+        });
+    });
 }
 /**
- * Main function to pack a project into a tarball
+ * Main function to pack a project into a zip file
  */
 async function packProject(pkg, projectPath) {
     const outputFilename = (0, metadata_1.getPackageName)(pkg);
     const absOutputPath = path.join(process.cwd(), outputFilename);
     try {
         validateProjectPath(projectPath);
-        validateRequiredFiles(projectPath);
-        const allFiles = collectProjectFiles(projectPath);
-        (0, LogService_1.log)(`Found ${allFiles.length} files to pack`).white();
-        (0, LogService_1.log)('Creating tarball...').white();
-        await createTarball(absOutputPath, projectPath, allFiles);
-        logTarballHash(absOutputPath);
-        (0, LogService_1.log)(`Tarball created at ${absOutputPath}`).white();
+        validateRequiredFiles(projectPath, pkg);
+        (0, LogService_1.log)('Creating package...').white();
+        await createZip(absOutputPath, projectPath);
+        await logPackageHash(absOutputPath);
+        (0, LogService_1.log)(`Package created at ${absOutputPath}`).white();
     }
     catch (err) {
-        (0, LogService_1.log)(`Failed to create tarball: ${err.message}`).red();
+        (0, LogService_1.log)(`Failed to create package: ${err.message}`).red();
         if (fs.existsSync(absOutputPath)) {
             fs.rmSync(absOutputPath);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@airmoney-degn/airmoney-cli",
-  "version": "0.23.0",
+  "version": "0.24.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"
@@ -31,6 +31,8 @@
   "dependencies": {
     "@solana/signers": "2.1.1",
     "@solana/web3.js": "1.98.2",
+    "@types/archiver": "^7.0.0",
+    "archiver": "^7.0.1",
     "base64-js": "^1.5.1",
     "bs58": "5.0.0",
     "commander": "^11.0.0",
@@ -69,4 +71,4 @@
     "typescript": "^5.0.4"
   },
   "packageManager": "npm@>=10.9.3 <11"
-}
+}

package/readme.md

@@ -7,18 +7,40 @@ It simplifies the process of creating, serving, and publishing applications to t
 ## Features
 
 - **Setup**: Setup your development environment with ease.
-- **Create**: Initialize new projects with a standard template structure.
+- **Create**: Initialize new projects with standard Web or Native (Rust/Slint) templates.
 - **Serve**: Test your project locally for development and testing on Simulator.
+- **Build**: Cross-compile native applications for AirMoney ARM devices.
 - **Upload**: Package and send your project to the DAPP store.
 
 ## Getting Started
-install `airmoney-cli` using `npm`.
 
-### Installation with npm
-Before you begin, ensure you have Node.js and npm installed on your machine.
-    
+### Installation
+
+Install `airmoney-cli` using `npm`:
+
+```bash
+npm install -g @airmoney-degn/airmoney-cli
+```
+
+### Native App Development Requirements
+
+To build and package **Native Applications**, you must have the following installed:
+1. **Docker**: Used by `cross` for cross-compilation environments.
+2. **Rust & Cargo**: Standard Rust toolchain.
+3. **Cross**: Install via `cargo install cross --git https://github.com/cross-rs/cross`.
+
+## Commands
+
+### 1. Setup
+Configure your developer address and API key.
+```bash
+airmoney-cli setup -u <YOUR_WALLET_ADDRESS> -k <YOUR_API_KEY>
+```
+
+### 2. Create Project
+Initialize a new project.
 ```bash
-npm install -g airmoney-cli
+airmoney-cli create -N my-app
 ```
 
 ## Release Process