@calimero-network/registry-cli 1.5.2 → 1.6.1

package/dist/index.js

@@ -4,7 +4,7 @@ import chalk6 from 'chalk';
 import ora6 from 'ora';
 import { table } from 'table';
 import axios from 'axios';
-import fs3, { existsSync, writeFileSync } from 'fs';
+import fs9, { existsSync, writeFileSync } from 'fs';
 import path7 from 'path';
 import os from 'os';
 import crypto from 'crypto';
@@ -430,10 +430,10 @@ var LocalConfig = class {
         allowedTypes: ["wasm", "js", "html"]
       }
     };
-    if (fs3.existsSync(this.configPath)) {
+    if (fs9.existsSync(this.configPath)) {
       try {
         const existingConfig = JSON.parse(
-          fs3.readFileSync(this.configPath, "utf8")
+          fs9.readFileSync(this.configPath, "utf8")
         );
         return {
           server: {
@@ -457,10 +457,10 @@ var LocalConfig = class {
   }
   saveConfig() {
     const configDir = path7.dirname(this.configPath);
-    if (!fs3.existsSync(configDir)) {
-      fs3.mkdirSync(configDir, { recursive: true });
+    if (!fs9.existsSync(configDir)) {
+      fs9.mkdirSync(configDir, { recursive: true });
     }
-    fs3.writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));
+    fs9.writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));
   }
   // Server configuration
   getPort() {
@@ -518,8 +518,8 @@ var LocalConfig = class {
       path7.join(this.getDataDir(), "logs")
     ];
     dirs.forEach((dir) => {
-      if (!fs3.existsSync(dir)) {
-        fs3.mkdirSync(dir, { recursive: true });
+      if (!fs9.existsSync(dir)) {
+        fs9.mkdirSync(dir, { recursive: true });
       }
     });
   }
@@ -574,21 +574,21 @@ var LocalDataStore = class {
   }
   loadData() {
     try {
-      if (fs3.existsSync(this.appsFile)) {
-        const appsData = JSON.parse(fs3.readFileSync(this.appsFile, "utf8"));
+      if (fs9.existsSync(this.appsFile)) {
+        const appsData = JSON.parse(fs9.readFileSync(this.appsFile, "utf8"));
         this.data.apps = new Map(Object.entries(appsData));
       }
-      if (fs3.existsSync(this.bundleManifestsFile)) {
+      if (fs9.existsSync(this.bundleManifestsFile)) {
         const bundleManifestsData = JSON.parse(
-          fs3.readFileSync(this.bundleManifestsFile, "utf8")
+          fs9.readFileSync(this.bundleManifestsFile, "utf8")
         );
         this.data.bundleManifests = new Map(
           Object.entries(bundleManifestsData)
         );
       }
-      if (fs3.existsSync(this.artifactsFile)) {
+      if (fs9.existsSync(this.artifactsFile)) {
         const artifactsData = JSON.parse(
-          fs3.readFileSync(this.artifactsFile, "utf8")
+          fs9.readFileSync(this.artifactsFile, "utf8")
         );
         this.data.artifacts = new Map(Object.entries(artifactsData));
       }
@@ -600,14 +600,14 @@ var LocalDataStore = class {
     try {
       this.config.ensureDirectories();
       const appsObj = Object.fromEntries(this.data.apps);
-      fs3.writeFileSync(this.appsFile, JSON.stringify(appsObj, null, 2));
+      fs9.writeFileSync(this.appsFile, JSON.stringify(appsObj, null, 2));
       const bundleManifestsObj = Object.fromEntries(this.data.bundleManifests);
-      fs3.writeFileSync(
+      fs9.writeFileSync(
         this.bundleManifestsFile,
         JSON.stringify(bundleManifestsObj, null, 2)
       );
       const artifactsObj = Object.fromEntries(this.data.artifacts);
-      fs3.writeFileSync(
+      fs9.writeFileSync(
         this.artifactsFile,
         JSON.stringify(artifactsObj, null, 2)
       );
@@ -690,8 +690,8 @@ var LocalDataStore = class {
       `backup-${timestamp}.json`
     );
     const backupDir = path7.dirname(backupPath);
-    if (!fs3.existsSync(backupDir)) {
-      fs3.mkdirSync(backupDir, { recursive: true });
+    if (!fs9.existsSync(backupDir)) {
+      fs9.mkdirSync(backupDir, { recursive: true });
     }
     const backupData = {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -699,14 +699,14 @@ var LocalDataStore = class {
       bundleManifests: Object.fromEntries(this.data.bundleManifests),
       artifacts: Object.fromEntries(this.data.artifacts)
     };
-    fs3.writeFileSync(backupPath, JSON.stringify(backupData, null, 2));
+    fs9.writeFileSync(backupPath, JSON.stringify(backupData, null, 2));
     return backupPath;
   }
   async restore(backupPath) {
-    if (!fs3.existsSync(backupPath)) {
+    if (!fs9.existsSync(backupPath)) {
       throw new Error(`Backup file not found: ${backupPath}`);
     }
-    const backupData = JSON.parse(fs3.readFileSync(backupPath, "utf8"));
+    const backupData = JSON.parse(fs9.readFileSync(backupPath, "utf8"));
     this.data.apps = new Map(Object.entries(backupData.apps || {}));
     this.data.bundleManifests = new Map(
       Object.entries(backupData.bundleManifests || {})
@@ -774,21 +774,21 @@ var LocalArtifactServer = class {
     this.ensureArtifactsDir();
   }
   ensureArtifactsDir() {
-    if (!fs3.existsSync(this.artifactsDir)) {
-      fs3.mkdirSync(this.artifactsDir, { recursive: true });
+    if (!fs9.existsSync(this.artifactsDir)) {
+      fs9.mkdirSync(this.artifactsDir, { recursive: true });
     }
   }
   // Copy artifact to local storage
   async copyArtifactToLocal(sourcePath, appId, version, filename) {
-    if (!fs3.existsSync(sourcePath)) {
+    if (!fs9.existsSync(sourcePath)) {
       throw new Error(`Source file not found: ${sourcePath}`);
     }
     const appVersionDir = path7.join(this.artifactsDir, appId, version);
-    if (!fs3.existsSync(appVersionDir)) {
-      fs3.mkdirSync(appVersionDir, { recursive: true });
+    if (!fs9.existsSync(appVersionDir)) {
+      fs9.mkdirSync(appVersionDir, { recursive: true });
     }
     const targetPath = path7.join(appVersionDir, filename);
-    fs3.copyFileSync(sourcePath, targetPath);
+    fs9.copyFileSync(sourcePath, targetPath);
     const fileHash = await this.calculateFileHash(targetPath);
     this.dataStore.setArtifactPath(fileHash, targetPath);
     return targetPath;
@@ -796,26 +796,26 @@ var LocalArtifactServer = class {
   // Serve artifact by app ID, version, and filename
   async serveArtifact(appId, version, filename) {
     const artifactPath = path7.join(this.artifactsDir, appId, version, filename);
-    if (!fs3.existsSync(artifactPath)) {
+    if (!fs9.existsSync(artifactPath)) {
       throw new Error(`Artifact not found: ${artifactPath}`);
     }
-    return fs3.readFileSync(artifactPath);
+    return fs9.readFileSync(artifactPath);
   }
   // Serve artifact by hash
   async serveByHash(hash) {
     const artifactPath = this.dataStore.getArtifactPath(hash);
-    if (!artifactPath || !fs3.existsSync(artifactPath)) {
+    if (!artifactPath || !fs9.existsSync(artifactPath)) {
       throw new Error(`Artifact not found for hash: ${hash}`);
     }
-    return fs3.readFileSync(artifactPath);
+    return fs9.readFileSync(artifactPath);
   }
   // Validate artifact file
   async validateArtifact(filePath) {
-    if (!fs3.existsSync(filePath)) {
+    if (!fs9.existsSync(filePath)) {
       throw new Error(`File not found: ${filePath}`);
     }
-    const stats = fs3.statSync(filePath);
-    const fileBuffer = fs3.readFileSync(filePath);
+    const stats = fs9.statSync(filePath);
+    const fileBuffer = fs9.readFileSync(filePath);
     const sha256 = crypto.createHash("sha256").update(fileBuffer).digest("hex");
     return {
       size: stats.size,
@@ -824,7 +824,7 @@ var LocalArtifactServer = class {
   }
   // Calculate file hash
   async calculateFileHash(filePath) {
-    const fileBuffer = fs3.readFileSync(filePath);
+    const fileBuffer = fs9.readFileSync(filePath);
     return crypto.createHash("sha256").update(fileBuffer).digest("hex");
   }
   // Get artifact URL for local serving
@@ -864,10 +864,10 @@ var LocalArtifactServer = class {
     const now = Date.now();
     const getAllFiles = (dir) => {
       let files = [];
-      const items = fs3.readdirSync(dir);
+      const items = fs9.readdirSync(dir);
       for (const item of items) {
         const fullPath = path7.join(dir, item);
-        const stat = fs3.statSync(fullPath);
+        const stat = fs9.statSync(fullPath);
         if (stat.isDirectory()) {
           files = files.concat(getAllFiles(fullPath));
         } else {
@@ -878,10 +878,10 @@ var LocalArtifactServer = class {
     };
     const allFiles = getAllFiles(this.artifactsDir);
     for (const file of allFiles) {
-      const stats = fs3.statSync(file);
+      const stats = fs9.statSync(file);
       const age = now - stats.mtime.getTime();
       if (age > maxAge) {
-        fs3.unlinkSync(file);
+        fs9.unlinkSync(file);
         console.log(`Cleaned up old artifact: ${file}`);
       }
     }
@@ -893,10 +893,10 @@ var LocalArtifactServer = class {
     let oldestFile = null;
     const getAllFiles = (dir) => {
       let files = [];
-      const items = fs3.readdirSync(dir);
+      const items = fs9.readdirSync(dir);
       for (const item of items) {
         const fullPath = path7.join(dir, item);
-        const stat = fs3.statSync(fullPath);
+        const stat = fs9.statSync(fullPath);
         if (stat.isDirectory()) {
           files = files.concat(getAllFiles(fullPath));
         } else {
@@ -905,10 +905,10 @@ var LocalArtifactServer = class {
       }
       return files;
     };
-    if (fs3.existsSync(this.artifactsDir)) {
+    if (fs9.existsSync(this.artifactsDir)) {
       const allFiles = getAllFiles(this.artifactsDir);
       for (const file of allFiles) {
-        const stats = fs3.statSync(file);
+        const stats = fs9.statSync(file);
         totalFiles++;
         totalSize += stats.size;
         if (!oldestFile || stats.mtime < oldestFile) {
@@ -994,7 +994,7 @@ var LocalRegistryClient = class {
     const processedManifest = { ...manifest };
     if (manifest.artifact?.uri?.startsWith("file://")) {
       const filePath = manifest.artifact.uri.replace("file://", "");
-      if (fs3.existsSync(filePath)) {
+      if (fs9.existsSync(filePath)) {
         const filename = path7.basename(filePath);
         try {
           await this.artifactServer.copyArtifactToLocal(
@@ -1138,12 +1138,12 @@ var appsCommand = new Command("apps").description("Manage SSApp applications").a
     const spinner2 = ora6("Reading manifest file...").start();
     try {
       const manifestPath = path7.resolve(manifestFile);
-      if (!fs3.existsSync(manifestPath)) {
+      if (!fs9.existsSync(manifestPath)) {
         spinner2.fail("Manifest file not found");
         console.error(chalk6.red(`File not found: ${manifestFile}`));
         process.exit(1);
       }
-      const manifestContent = fs3.readFileSync(manifestPath, "utf8");
+      const manifestContent = fs9.readFileSync(manifestPath, "utf8");
       const manifest = JSON.parse(manifestContent);
       spinner2.text = "Submitting application manifest...";
       const result = await client.submitAppManifest(manifest);
@@ -1423,8 +1423,8 @@ var LocalRegistryServer = class {
   async reset() {
     this.dataStore.reset();
     const artifactsDir = this.config.getArtifactsDir();
-    if (fs3.existsSync(artifactsDir)) {
-      fs3.rmSync(artifactsDir, { recursive: true, force: true });
+    if (fs9.existsSync(artifactsDir)) {
+      fs9.rmSync(artifactsDir, { recursive: true, force: true });
     }
   }
   async backup(outputPath) {
@@ -1727,7 +1727,7 @@ localCommand.addCommand(
   new Command("restore").description("Restore local registry data from backup").argument("<backup-file>", "Path to backup file").action(async (backupFile) => {
     const spinner2 = ora6("Restoring from backup...").start();
     try {
-      if (!fs3.existsSync(backupFile)) {
+      if (!fs9.existsSync(backupFile)) {
         spinner2.fail("Backup file not found");
         console.error(chalk6.red(`File not found: ${backupFile}`));
         process.exit(1);
@@ -1786,10 +1786,10 @@ var RemoteConfig = class {
         url: "https://apps.calimero.network"
       }
     };
-    if (fs3.existsSync(this.configPath)) {
+    if (fs9.existsSync(this.configPath)) {
       try {
         const existingConfig = JSON.parse(
-          fs3.readFileSync(this.configPath, "utf8")
+          fs9.readFileSync(this.configPath, "utf8")
         );
         return {
           registry: {
@@ -1805,8 +1805,8 @@ var RemoteConfig = class {
   }
   saveConfig() {
     const configDir = path7.dirname(this.configPath);
-    if (!fs3.existsSync(configDir)) {
-      fs3.mkdirSync(configDir, { recursive: true });
+    if (!fs9.existsSync(configDir)) {
+      fs9.mkdirSync(configDir, { recursive: true });
     }
     const configToSave = {
       registry: {
@@ -1815,7 +1815,7 @@ var RemoteConfig = class {
         ...this.config.registry.apiKey ? { apiKey: this.config.registry.apiKey } : {}
       }
     };
-    fs3.writeFileSync(this.configPath, JSON.stringify(configToSave, null, 2));
+    fs9.writeFileSync(this.configPath, JSON.stringify(configToSave, null, 2));
   }
   /**
    * Get registry URL with priority:
@@ -1890,7 +1890,10 @@ var RemoteConfig = class {
 // src/commands/bundle.ts
 var bundleCommand = new Command("bundle").description("Manage application bundles (V2)").addCommand(createCreateCommand()).addCommand(createPushCommand()).addCommand(createGetCommand());
 function createCreateCommand() {
-  return new Command("create").description("Create an MPK bundle from a WASM file").argument("<wasm-file>", "Path to the WASM file").argument("<package>", "Package name (e.g. com.calimero.myapp)").argument("<version>", "Version (e.g. 1.0.0)").option("-o, --output <path>", "Output path for the MPK file").option("--name <name>", "Application name").option("--description <description>", "Application description").option("--author <author>", "Application author", "Calimero Team").option("--frontend <url>", "Frontend URL").option("--github <url>", "GitHub URL").option("--docs <url>", "Documentation URL").option(
+  return new Command("create").description("Create an MPK bundle from a WASM file").argument("<wasm-file>", "Path to the WASM file").argument("[package]", "Package name (e.g. com.calimero.myapp)").argument("[version]", "Version (e.g. 1.0.0)").option(
+    "-m, --manifest <path>",
+    "Path to manifest JSON file (can contain package, version, and other options)"
+  ).option("-o, --output <path>", "Output path for the MPK file").option("--name <name>", "Application name").option("--description <description>", "Application description").option("--author <author>", "Application author").option("--frontend <url>", "Frontend URL").option("--github <url>", "GitHub URL").option("--docs <url>", "Documentation URL").option(
     "--export <interface>",
     "Export interface (can be specified multiple times)",
     (value, prev) => {
@@ -1902,88 +1905,258 @@ function createCreateCommand() {
     (value, prev) => {
       return [...prev || [], value];
     }
+  ).option("--abi <path>", "Path to ABI JSON file to include in bundle").addHelpText(
+    "after",
+    `
+Examples:
+  $ calimero-registry bundle create app.wasm com.calimero.myapp 1.0.0
+  $ calimero-registry bundle create app.wasm --manifest bundle-manifest.json
+  $ calimero-registry bundle create app.wasm --manifest bundle-manifest.json -o output.mpk
+  $ calimero-registry bundle create app.wasm com.calimero.myapp 1.0.0 --name "My App" --frontend https://app.example.com
+  $ calimero-registry bundle create app.wasm com.calimero.myapp 1.0.0 --abi abi.json
+  $ calimero-registry bundle create app.wasm --manifest manifest.json --abi res/abi.json
+
+Manifest File Format (JSON):
+  {
+    "package": "com.calimero.myapp",
+    "version": "1.0.0",
+    "output": "./dist/myapp.mpk",
+    "name": "My Application",
+    "description": "Application description",
+    "author": "Calimero Team",
+    "frontend": "https://app.example.com",
+    "github": "https://github.com/user/repo",
+    "docs": "https://docs.example.com",
+    "exports": ["interface1", "interface2"],
+    "uses": ["interface3"],
+    "abi": "res/abi.json"
+  }
+
+Note:
+  - Package and version can be provided via arguments, manifest file, or both
+  - CLI arguments take precedence over manifest file values
+  - If using manifest file, package and version can be omitted from command line
+  - The -o/--output option overrides manifest.output if both are provided
+  - ABI can be provided via --abi flag or manifest.abi field (file path string)
+  - ABI file will be included in the bundle and referenced in the manifest
+`
   ).action(async (wasmFile, pkg, version, options) => {
     try {
+      let manifestConfig = {};
+      if (options.manifest) {
+        const manifestPath = path7.resolve(options.manifest);
+        if (!fs9.existsSync(manifestPath)) {
+          console.error(`\u274C Manifest file not found: ${options.manifest}`);
+          process.exit(1);
+        }
+        try {
+          const manifestContent = fs9.readFileSync(manifestPath, "utf8");
+          const parsed = JSON.parse(manifestContent);
+          if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+            console.error(`\u274C Invalid manifest file: ${options.manifest}`);
+            console.error("   Manifest must be a JSON object");
+            process.exit(1);
+          }
+          manifestConfig = parsed;
+        } catch (error) {
+          console.error(
+            `\u274C Failed to parse manifest file: ${options.manifest}`
+          );
+          console.error(
+            error instanceof Error ? error.message : "Invalid JSON"
+          );
+          process.exit(1);
+        }
+      }
+      const finalPackage = pkg || manifestConfig.package;
+      const finalVersion = version || manifestConfig.version;
+      const finalOutput = options.output || manifestConfig.output;
+      const finalName = options.name || manifestConfig.name;
+      const finalDescription = options.description || manifestConfig.description;
+      const finalAuthor = options.author || manifestConfig.author || "Calimero Team";
+      const finalFrontend = options.frontend || manifestConfig.frontend;
+      const finalGithub = options.github || manifestConfig.github;
+      const finalDocs = options.docs || manifestConfig.docs;
+      const manifestExports = manifestConfig.exports;
+      const manifestUses = manifestConfig.uses;
+      if (manifestExports !== void 0 && !Array.isArray(manifestExports)) {
+        console.error('\u274C Invalid manifest: "exports" must be an array');
+        process.exit(1);
+      }
+      if (manifestUses !== void 0 && !Array.isArray(manifestUses)) {
+        console.error('\u274C Invalid manifest: "uses" must be an array');
+        process.exit(1);
+      }
+      const finalExports = options.export && options.export.length > 0 ? options.export : manifestExports || [];
+      const finalUses = options.use && options.use.length > 0 ? options.use : manifestUses || [];
+      if (!wasmFile) {
+        console.error("\u274C WASM file is required");
+        process.exit(1);
+      }
+      if (!finalPackage) {
+        console.error(
+          "\u274C Package name is required (provide via argument, --manifest file, or manifest.package)"
+        );
+        process.exit(1);
+      }
+      if (!finalVersion) {
+        console.error(
+          "\u274C Version is required (provide via argument, --manifest file, or manifest.version)"
+        );
+        process.exit(1);
+      }
+      if (!/^[a-z0-9-]+(\.[a-z0-9-]+)+$/.test(finalPackage)) {
+        console.error(
+          "\u274C Invalid package name format. Expected format: com.calimero.myapp or com.my-org.my-app"
+        );
+        process.exit(1);
+      }
+      if (!/^\d+\.\d+\.\d+(-[a-z0-9.-]+)?(\+[a-z0-9.-]+)?$/i.test(finalVersion)) {
+        console.error(
+          "\u274C Invalid version format. Expected format: 1.0.0, 1.0.0-alpha, or 1.0.0-alpha.1"
+        );
+        process.exit(1);
+      }
       const wasmPath = path7.resolve(wasmFile);
-      if (!fs3.existsSync(wasmPath)) {
+      if (!fs9.existsSync(wasmPath)) {
         console.error(`\u274C WASM file not found: ${wasmFile}`);
         process.exit(1);
       }
       console.log(`\u{1F4E6} Creating MPK bundle from: ${path7.basename(wasmPath)}`);
-      const wasmContent = fs3.readFileSync(wasmPath);
+      const wasmContent = fs9.readFileSync(wasmPath);
       const wasmSize = wasmContent.length;
-      const hash = crypto.createHash("sha256").update(wasmContent).digest("hex");
+      const wasmHash = crypto.createHash("sha256").update(wasmContent).digest("hex");
+      let abiArtifact = void 0;
+      let abiContent = null;
+      const abiPathFromOption = options.abi;
+      const abiPathFromManifest = typeof manifestConfig.abi === "string" ? manifestConfig.abi : null;
+      const abiFilePath = abiPathFromOption || abiPathFromManifest;
+      if (abiFilePath) {
+        const abiResolvedPath = abiPathFromOption ? path7.resolve(abiFilePath) : options.manifest && abiPathFromManifest ? path7.resolve(
+          path7.dirname(path7.resolve(options.manifest)),
+          abiFilePath
+        ) : path7.resolve(abiFilePath);
+        if (!fs9.existsSync(abiResolvedPath)) {
+          console.error(`\u274C ABI file not found: ${abiFilePath}`);
+          console.error(`   Resolved path: ${abiResolvedPath}`);
+          process.exit(1);
+        }
+        try {
+          abiContent = fs9.readFileSync(abiResolvedPath);
+          JSON.parse(abiContent.toString("utf8"));
+          const abiHash = crypto.createHash("sha256").update(abiContent).digest("hex");
+          abiArtifact = {
+            path: "abi.json",
+            hash: abiHash,
+            size: abiContent.length
+          };
+          console.log(
+            `   Including ABI file: ${path7.basename(abiResolvedPath)}`
+          );
+        } catch (error) {
+          console.error(
+            `\u274C Failed to read or parse ABI file: ${abiFilePath}`
+          );
+          console.error(
+            error instanceof Error ? error.message : "Invalid JSON"
+          );
+          process.exit(1);
+        }
+      } else if (manifestConfig.abi && typeof manifestConfig.abi === "object") {
+        console.error(
+          "\u274C Manifest provides ABI as object, but --abi flag is required to include the ABI file in bundle"
+        );
+        console.error(
+          "   Provide the ABI file path with --abi flag, or change manifest.abi to a file path string"
+        );
+        process.exit(1);
+      }
       const metadata = {
-        name: options.name || pkg,
-        description: options.description || "",
-        author: options.author || "Calimero Team"
+        name: finalName || finalPackage,
+        description: finalDescription || "",
+        author: finalAuthor
       };
       const links = {};
-      if (options.frontend) links.frontend = options.frontend;
-      if (options.github) links.github = options.github;
-      if (options.docs) links.docs = options.docs;
+      if (finalFrontend) links.frontend = finalFrontend;
+      if (finalGithub) links.github = finalGithub;
+      if (finalDocs) links.docs = finalDocs;
       const interfaces = {
-        exports: options.export || [],
-        uses: options.use || []
+        exports: finalExports,
+        uses: finalUses
       };
       const manifest = {
         version: "1.0",
-        package: pkg,
-        appVersion: version,
+        package: finalPackage,
+        appVersion: finalVersion,
         metadata: Object.keys(metadata).length > 0 ? metadata : void 0,
         interfaces: interfaces.exports.length > 0 || interfaces.uses.length > 0 ? interfaces : void 0,
         wasm: {
           path: "app.wasm",
-          hash,
+          hash: wasmHash,
           size: wasmSize
         },
-        abi: null,
+        abi: abiArtifact || void 0,
         migrations: [],
         links: Object.keys(links).length > 0 ? links : void 0,
         signature: void 0
       };
-      let outputPath = options.output;
+      let outputPath = finalOutput;
       if (!outputPath) {
-        const outputDir = path7.join(process.cwd(), pkg, version);
-        if (!fs3.existsSync(outputDir)) {
-          fs3.mkdirSync(outputDir, { recursive: true });
+        const outputDir = path7.join(
+          process.cwd(),
+          finalPackage,
+          finalVersion
+        );
+        if (!fs9.existsSync(outputDir)) {
+          fs9.mkdirSync(outputDir, { recursive: true });
         }
-        outputPath = path7.join(outputDir, `${pkg}-${version}.mpk`);
+        outputPath = path7.join(
+          outputDir,
+          `${finalPackage}-${finalVersion}.mpk`
+        );
       } else {
         outputPath = path7.resolve(outputPath);
         const outputDir = path7.dirname(outputPath);
-        if (!fs3.existsSync(outputDir)) {
-          fs3.mkdirSync(outputDir, { recursive: true });
+        if (!fs9.existsSync(outputDir)) {
+          fs9.mkdirSync(outputDir, { recursive: true });
         }
       }
       const tempDir = path7.join(
         path7.dirname(outputPath),
         `.temp-bundle-${Date.now()}`
       );
-      fs3.mkdirSync(tempDir, { recursive: true });
+      fs9.mkdirSync(tempDir, { recursive: true });
       try {
-        fs3.writeFileSync(
+        fs9.writeFileSync(
           path7.join(tempDir, "manifest.json"),
           JSON.stringify(manifest, null, 2)
         );
-        fs3.writeFileSync(path7.join(tempDir, "app.wasm"), wasmContent);
+        fs9.writeFileSync(path7.join(tempDir, "app.wasm"), wasmContent);
+        const archiveFiles = ["manifest.json", "app.wasm"];
+        if (abiContent) {
+          fs9.writeFileSync(path7.join(tempDir, "abi.json"), abiContent);
+          archiveFiles.push("abi.json");
+        }
         await tar.create(
           {
             gzip: true,
             file: outputPath,
             cwd: tempDir
           },
-          ["manifest.json", "app.wasm"]
+          archiveFiles
         );
-        const outputSize = fs3.statSync(outputPath).size;
+        const outputSize = fs9.statSync(outputPath).size;
         console.log(`\u2705 Created MPK bundle: ${outputPath}`);
-        console.log(`   Package: ${pkg}`);
-        console.log(`   Version: ${version}`);
+        console.log(`   Package: ${finalPackage}`);
+        console.log(`   Version: ${finalVersion}`);
         console.log(`   Size: ${outputSize} bytes`);
-        console.log(`   WASM Hash: ${hash}`);
+        console.log(`   WASM Hash: ${wasmHash}`);
+        if (abiArtifact) {
+          console.log(`   ABI Hash: ${abiArtifact.hash}`);
+        }
       } finally {
-        if (fs3.existsSync(tempDir)) {
-          fs3.rmSync(tempDir, { recursive: true, force: true });
+        if (fs9.existsSync(tempDir)) {
+          fs9.rmSync(tempDir, { recursive: true, force: true });
         }
       }
     } catch (error) {
@@ -2049,7 +2222,7 @@ Note:
         process.exit(1);
       }
       const fullPath = path7.resolve(bundleFile);
-      if (!fs3.existsSync(fullPath)) {
+      if (!fs9.existsSync(fullPath)) {
         console.error(`\u274C File not found: ${bundleFile}`);
         process.exit(1);
       }
@@ -2128,7 +2301,7 @@ function createGetCommand() {
 async function pushToRemote(bundlePath, manifest, registryUrl, apiKey) {
   try {
     console.log(`\u{1F4E4} Pushing to remote registry: ${registryUrl}`);
-    const bundleBuffer = fs3.readFileSync(bundlePath);
+    const bundleBuffer = fs9.readFileSync(bundlePath);
     const bundleSize = bundleBuffer.length;
     console.log(`   Bundle size: ${bundleSize} bytes`);
     const bundleHex = bundleBuffer.toString("hex");
@@ -2302,8 +2475,8 @@ async function extractManifest(bundlePath) {
     }
   });
   const extractDir = path7.join(path7.dirname(bundlePath), `.temp-${Date.now()}`);
-  if (!fs3.existsSync(extractDir)) {
-    fs3.mkdirSync(extractDir);
+  if (!fs9.existsSync(extractDir)) {
+    fs9.mkdirSync(extractDir);
   }
   try {
     await tar.x({
@@ -2312,14 +2485,14 @@ async function extractManifest(bundlePath) {
       filter: (path8) => path8 === "manifest.json"
     });
     const manifestPath = path7.join(extractDir, "manifest.json");
-    if (fs3.existsSync(manifestPath)) {
-      const content = fs3.readFileSync(manifestPath, "utf8");
+    if (fs9.existsSync(manifestPath)) {
+      const content = fs9.readFileSync(manifestPath, "utf8");
       manifestContent = content;
     }
   } catch {
   } finally {
-    if (fs3.existsSync(extractDir)) {
-      fs3.rmSync(extractDir, { recursive: true, force: true });
+    if (fs9.existsSync(extractDir)) {
+      fs9.rmSync(extractDir, { recursive: true, force: true });
     }
   }
   if (manifestContent) {
@@ -2416,7 +2589,7 @@ function createConfigListCommand() {
       const config = new RemoteConfig();
       console.log(chalk6.blue("\n\u{1F4CB} Remote Registry Configuration\n"));
       const configPath = config.getConfigPath();
-      const configFileExists = fs3.existsSync(configPath);
+      const configFileExists = fs9.existsSync(configPath);
       const url = config.getRegistryUrl();
       let urlSource;
       if (process.env.CALIMERO_REGISTRY_URL) {