@calimero-network/registry-cli 1.2.0 → 1.4.2

package/dist/index.js

@@ -5,40 +5,40 @@ import ora6 from 'ora';
 import { table } from 'table';
 import { SSAppRegistryClient } from '@calimero-network/registry-client';
 import fs3, { existsSync, writeFileSync } from 'fs';
-import path from 'path';
+import path6 from 'path';
 import os from 'os';
 import crypto from 'crypto';
 import fastify from 'fastify';
 import cors from '@fastify/cors';
-import { Buffer } from 'buffer';
-import fetch from 'node-fetch';
+import * as tar from 'tar';
 
 var LocalConfig = class {
   constructor() {
-    this.configPath = path.join(
+    this.configPath = path6.join(
       os.homedir(),
       ".calimero-registry",
       "config.json"
     );
-    this.dataDir = path.join(os.homedir(), ".calimero-registry");
+    this.dataDir = path6.join(os.homedir(), ".calimero-registry");
     this.config = this.loadConfig();
   }
   loadConfig() {
     const defaultConfig = {
       server: {
         port: 8082,
-        host: "localhost"
+        host: "0.0.0.0",
+        publicHost: "host.docker.internal"
       },
       data: {
-        dir: path.join(os.homedir(), ".calimero-registry", "data"),
-        artifactsDir: path.join(
+        dir: path6.join(os.homedir(), ".calimero-registry", "data"),
+        artifactsDir: path6.join(
           os.homedir(),
           ".calimero-registry",
           "artifacts"
         )
       },
       artifacts: {
-        storageDir: path.join(os.homedir(), ".calimero-registry", "artifacts"),
+        storageDir: path6.join(os.homedir(), ".calimero-registry", "artifacts"),
         serveLocal: true,
         copyArtifacts: true,
         maxFileSize: "100MB",
@@ -50,7 +50,20 @@ var LocalConfig = class {
         const existingConfig = JSON.parse(
           fs3.readFileSync(this.configPath, "utf8")
         );
-        return { ...defaultConfig, ...existingConfig };
+        return {
+          server: {
+            ...defaultConfig.server,
+            ...existingConfig.server || {}
+          },
+          data: {
+            ...defaultConfig.data,
+            ...existingConfig.data || {}
+          },
+          artifacts: {
+            ...defaultConfig.artifacts,
+            ...existingConfig.artifacts || {}
+          }
+        };
       } catch {
         console.warn("Failed to load existing config, using defaults");
       }
@@ -58,7 +71,7 @@ var LocalConfig = class {
     return defaultConfig;
   }
   saveConfig() {
-    const configDir = path.dirname(this.configPath);
+    const configDir = path6.dirname(this.configPath);
     if (!fs3.existsSync(configDir)) {
       fs3.mkdirSync(configDir, { recursive: true });
     }
@@ -79,13 +92,20 @@ var LocalConfig = class {
     this.config.server.host = host;
     this.saveConfig();
   }
+  getPublicHost() {
+    return this.config.server.publicHost;
+  }
+  setPublicHost(host) {
+    this.config.server.publicHost = host;
+    this.saveConfig();
+  }
   // Data directory configuration
   getDataDir() {
     return this.config.data.dir;
   }
   setDataDir(dir) {
     this.config.data.dir = dir;
-    this.config.artifacts.storageDir = path.join(dir, "artifacts");
+    this.config.artifacts.storageDir = path6.join(dir, "artifacts");
     this.saveConfig();
   }
   getArtifactsDir() {
@@ -109,8 +129,8 @@ var LocalConfig = class {
     const dirs = [
       this.getDataDir(),
       this.getArtifactsDir(),
-      path.join(this.getDataDir(), "backups"),
-      path.join(this.getDataDir(), "logs")
+      path6.join(this.getDataDir(), "backups"),
+      path6.join(this.getDataDir(), "logs")
     ];
     dirs.forEach((dir) => {
       if (!fs3.existsSync(dir)) {
@@ -133,15 +153,15 @@ var LocalConfig = class {
         host: "localhost"
       },
       data: {
-        dir: path.join(os.homedir(), ".calimero-registry", "data"),
-        artifactsDir: path.join(
+        dir: path6.join(os.homedir(), ".calimero-registry", "data"),
+        artifactsDir: path6.join(
           os.homedir(),
           ".calimero-registry",
           "artifacts"
         )
       },
       artifacts: {
-        storageDir: path.join(os.homedir(), ".calimero-registry", "artifacts"),
+        storageDir: path6.join(os.homedir(), ".calimero-registry", "artifacts"),
         serveLocal: true,
         copyArtifacts: true,
         maxFileSize: "100MB",
@@ -154,12 +174,15 @@ var LocalConfig = class {
 var LocalDataStore = class {
   constructor(config) {
     this.config = config;
-    this.appsFile = path.join(config.getDataDir(), "apps.json");
-    this.manifestsFile = path.join(config.getDataDir(), "manifests.json");
-    this.artifactsFile = path.join(config.getDataDir(), "artifacts.json");
+    this.appsFile = path6.join(config.getDataDir(), "apps.json");
+    this.bundleManifestsFile = path6.join(
+      config.getDataDir(),
+      "bundle_manifests.json"
+    );
+    this.artifactsFile = path6.join(config.getDataDir(), "artifacts.json");
     this.data = {
       apps: /* @__PURE__ */ new Map(),
-      manifests: /* @__PURE__ */ new Map(),
+      bundleManifests: /* @__PURE__ */ new Map(),
       artifacts: /* @__PURE__ */ new Map()
     };
     this.loadData();
@@ -170,11 +193,13 @@ var LocalDataStore = class {
         const appsData = JSON.parse(fs3.readFileSync(this.appsFile, "utf8"));
         this.data.apps = new Map(Object.entries(appsData));
       }
-      if (fs3.existsSync(this.manifestsFile)) {
-        const manifestsData = JSON.parse(
-          fs3.readFileSync(this.manifestsFile, "utf8")
+      if (fs3.existsSync(this.bundleManifestsFile)) {
+        const bundleManifestsData = JSON.parse(
+          fs3.readFileSync(this.bundleManifestsFile, "utf8")
+        );
+        this.data.bundleManifests = new Map(
+          Object.entries(bundleManifestsData)
         );
-        this.data.manifests = new Map(Object.entries(manifestsData));
       }
       if (fs3.existsSync(this.artifactsFile)) {
         const artifactsData = JSON.parse(
@@ -191,10 +216,10 @@ var LocalDataStore = class {
       this.config.ensureDirectories();
       const appsObj = Object.fromEntries(this.data.apps);
       fs3.writeFileSync(this.appsFile, JSON.stringify(appsObj, null, 2));
-      const manifestsObj = Object.fromEntries(this.data.manifests);
+      const bundleManifestsObj = Object.fromEntries(this.data.bundleManifests);
       fs3.writeFileSync(
-        this.manifestsFile,
-        JSON.stringify(manifestsObj, null, 2)
+        this.bundleManifestsFile,
+        JSON.stringify(bundleManifestsObj, null, 2)
       );
       const artifactsObj = Object.fromEntries(this.data.artifacts);
       fs3.writeFileSync(
@@ -210,12 +235,12 @@ var LocalDataStore = class {
   // Apps management
   getApps(filters) {
     let apps = Array.from(this.data.apps.values());
-    if (filters?.dev) {
-      apps = apps.filter((app) => app.developer_pubkey === filters.dev);
-    }
     if (filters?.name) {
       apps = apps.filter((app) => app.name.includes(filters.name));
     }
+    if (filters?.dev) {
+      apps = apps.filter((app) => app.developer_pubkey === filters.dev);
+    }
     return apps;
   }
   getApp(appKey) {
@@ -225,17 +250,19 @@ var LocalDataStore = class {
     this.data.apps.set(appKey, app);
     this.saveData();
   }
-  // Versions management
-  getAppVersions(appId) {
+  // Versions management (bundles only)
+  getAppVersions(packageId) {
     const versions = [];
-    for (const [key, manifest] of this.data.manifests.entries()) {
-      if (key.startsWith(`${appId}/`)) {
+    for (const [key, manifest] of this.data.bundleManifests.entries()) {
+      if (key.startsWith(`${packageId}/`)) {
         const semver = key.split("/").pop();
+        const digest = manifest.wasm?.hash || "";
         versions.push({
           semver,
-          cid: manifest.artifacts[0]?.cid || "",
+          digest,
+          cid: digest,
+          // Compatibility
           yanked: false
-          // TODO: Implement yanking
         });
       }
     }
@@ -243,13 +270,14 @@ var LocalDataStore = class {
       (a, b) => a.semver.localeCompare(b.semver, void 0, { numeric: true })
     );
   }
-  // Manifest management
-  getManifest(appId, semver) {
-    const manifestKey = `${appId}/${semver}`;
-    return this.data.manifests.get(manifestKey);
+  // Manifest management (V2 / Bundles)
+  getBundleManifest(pkg, version) {
+    const key = `${pkg}/${version}`;
+    return this.data.bundleManifests.get(key);
   }
-  setManifest(manifestKey, manifest) {
-    this.data.manifests.set(manifestKey, manifest);
+  setBundleManifest(pkg, version, manifest) {
+    const key = `${pkg}/${version}`;
+    this.data.bundleManifests.set(key, manifest);
     this.saveData();
   }
   // Artifact management
@@ -264,26 +292,26 @@ var LocalDataStore = class {
   getStats() {
     return {
       publishedApps: this.data.apps.size,
-      totalVersions: this.data.manifests.size,
+      totalVersions: this.data.bundleManifests.size,
       totalArtifacts: this.data.artifacts.size
     };
   }
   // Backup and restore
   async backup(outputPath) {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const backupPath = outputPath || path.join(
+    const backupPath = outputPath || path6.join(
       this.config.getDataDir(),
       "backups",
       `backup-${timestamp}.json`
     );
-    const backupDir = path.dirname(backupPath);
+    const backupDir = path6.dirname(backupPath);
     if (!fs3.existsSync(backupDir)) {
       fs3.mkdirSync(backupDir, { recursive: true });
     }
     const backupData = {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       apps: Object.fromEntries(this.data.apps),
-      manifests: Object.fromEntries(this.data.manifests),
+      bundleManifests: Object.fromEntries(this.data.bundleManifests),
       artifacts: Object.fromEntries(this.data.artifacts)
     };
     fs3.writeFileSync(backupPath, JSON.stringify(backupData, null, 2));
@@ -295,83 +323,62 @@ var LocalDataStore = class {
     }
     const backupData = JSON.parse(fs3.readFileSync(backupPath, "utf8"));
     this.data.apps = new Map(Object.entries(backupData.apps || {}));
-    this.data.manifests = new Map(Object.entries(backupData.manifests || {}));
+    this.data.bundleManifests = new Map(
+      Object.entries(backupData.bundleManifests || {})
+    );
     this.data.artifacts = new Map(Object.entries(backupData.artifacts || {}));
     this.saveData();
   }
   // Reset data
   reset() {
     this.data.apps.clear();
-    this.data.manifests.clear();
+    this.data.bundleManifests.clear();
     this.data.artifacts.clear();
     this.saveData();
   }
+  /**
+   * Get all bundle manifests
+   */
+  getAllBundles() {
+    return Array.from(this.data.bundleManifests.values());
+  }
   // Seed with sample data
   async seed() {
-    const sampleApps = [
-      {
-        name: "sample-wallet",
-        developer_pubkey: "ed25519:5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY",
-        latest_version: "1.0.0",
-        latest_cid: "QmSampleWallet123",
-        alias: "Sample Wallet"
+    const bundleManifest = {
+      version: "1.0",
+      package: "com.calimero.sample-bundle",
+      appVersion: "1.0.0",
+      metadata: {
+        name: "Sample Bundle App",
+        description: "A sample application using V2 Bundle Manifest",
+        tags: ["sample", "v2"],
+        license: "MIT"
       },
-      {
-        name: "demo-dex",
-        developer_pubkey: "ed25519:5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty",
-        latest_version: "2.1.0",
-        latest_cid: "QmDemoDex456",
-        alias: "Demo DEX"
-      }
-    ];
-    const sampleManifests = [
-      {
-        manifest_version: "1.0",
-        app: {
-          name: "sample-wallet",
-          namespace: "com.example",
-          developer_pubkey: "ed25519:5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY",
-          id: "sample-wallet-id",
-          alias: "Sample Wallet"
-        },
-        version: {
-          semver: "1.0.0"
-        },
-        supported_chains: ["mainnet", "testnet"],
-        permissions: [
-          { cap: "wallet", bytes: 1024 },
-          { cap: "network", bytes: 512 }
-        ],
-        artifacts: [
-          {
-            type: "wasm",
-            target: "node",
-            path: "/artifacts/sample-wallet/1.0.0/app.wasm",
-            size: 1024e3,
-            sha256: "abc123def456"
-          }
-        ],
-        metadata: {
-          description: "A sample wallet application for testing",
-          author: "Sample Developer"
-        },
-        distribution: "local",
-        signature: {
-          alg: "ed25519",
-          sig: "sample-signature",
-          signed_at: (/* @__PURE__ */ new Date()).toISOString()
-        }
-      }
-    ];
-    sampleApps.forEach((app) => {
-      const appKey = `${app.developer_pubkey}/${app.name}`;
-      this.setApp(appKey, app);
-    });
-    sampleManifests.forEach((manifest) => {
-      const manifestKey = `${manifest.app.app_id}/${manifest.version.semver}`;
-      this.setManifest(manifestKey, manifest);
-    });
-    this.saveData();
+      interfaces: {
+        exports: ["com.calimero.sample.v1"],
+        uses: []
+      },
+      links: {
+        frontend: "https://example.com/app",
+        github: "https://github.com/example/app"
+      },
+      wasm: {
+        path: "app.wasm",
+        size: 1024,
+        hash: null
+      },
+      abi: {
+        path: "abi.json",
+        size: 512,
+        hash: null
+      },
+      migrations: []
+    };
+    this.setBundleManifest(
+      bundleManifest.package,
+      bundleManifest.appVersion,
+      bundleManifest
+    );
   }
 };
 var LocalArtifactServer = class {
@@ -391,11 +398,11 @@ var LocalArtifactServer = class {
     if (!fs3.existsSync(sourcePath)) {
       throw new Error(`Source file not found: ${sourcePath}`);
     }
-    const appVersionDir = path.join(this.artifactsDir, appId, version);
+    const appVersionDir = path6.join(this.artifactsDir, appId, version);
     if (!fs3.existsSync(appVersionDir)) {
       fs3.mkdirSync(appVersionDir, { recursive: true });
     }
-    const targetPath = path.join(appVersionDir, filename);
+    const targetPath = path6.join(appVersionDir, filename);
     fs3.copyFileSync(sourcePath, targetPath);
     const fileHash = await this.calculateFileHash(targetPath);
     this.dataStore.setArtifactPath(fileHash, targetPath);
@@ -403,7 +410,7 @@ var LocalArtifactServer = class {
   }
   // Serve artifact by app ID, version, and filename
   async serveArtifact(appId, version, filename) {
-    const artifactPath = path.join(this.artifactsDir, appId, version, filename);
+    const artifactPath = path6.join(this.artifactsDir, appId, version, filename);
     if (!fs3.existsSync(artifactPath)) {
       throw new Error(`Artifact not found: ${artifactPath}`);
     }
@@ -437,35 +444,33 @@ var LocalArtifactServer = class {
   }
   // Get artifact URL for local serving
   getArtifactUrl(appId, version, filename) {
-    const baseUrl = `http://${this.config.getHost()}:${this.config.getPort()}`;
+    const baseUrl = `http://${this.config.getPublicHost()}:${this.config.getPort()}`;
     return `${baseUrl}/artifacts/${appId}/${version}/${filename}`;
   }
   // Get artifact URL by hash
   getArtifactUrlByHash(hash) {
-    const baseUrl = `http://${this.config.getHost()}:${this.config.getPort()}`;
+    const baseUrl = `http://${this.config.getPublicHost()}:${this.config.getPort()}`;
     return `${baseUrl}/artifacts/${hash}`;
   }
-  // Update manifest artifacts to use local URLs
-  updateManifestArtifacts(manifest) {
+  // Update manifest artifact to use local URLs (and preserve HTTP access)
+  updateManifestArtifact(manifest) {
     const updatedManifest = { ...manifest };
-    if (updatedManifest.artifacts) {
-      updatedManifest.artifacts = updatedManifest.artifacts.map(
-        (artifact) => {
-          const updatedArtifact = { ...artifact };
-          if (artifact.path) {
-            const filename = path.basename(artifact.path);
-            updatedArtifact.mirrors = [
-              this.getArtifactUrl(
-                manifest.app.id || manifest.app.name?.replace(/\s+/g, "-").toLowerCase(),
-                manifest.version.semver,
-                filename
-              )
-            ];
-            delete updatedArtifact.path;
-          }
-          return updatedArtifact;
-        }
-      );
+    if (!manifest.artifact?.uri) {
+      return updatedManifest;
+    }
+    const uri = manifest.artifact.uri;
+    if (uri.startsWith("/")) {
+      updatedManifest.artifact = {
+        ...manifest.artifact,
+        uri: `${this.getArtifactUrl(manifest.id, manifest.version, path6.basename(manifest.artifact.uri))}`
+      };
+    } else if (uri.startsWith("file://")) {
+      const filePath = uri.replace("file://", "");
+      const filename = path6.basename(filePath);
+      updatedManifest.artifact = {
+        ...manifest.artifact,
+        uri: this.getArtifactUrl(manifest.id, manifest.version, filename)
+      };
     }
     return updatedManifest;
   }
@@ -476,7 +481,7 @@ var LocalArtifactServer = class {
       let files = [];
       const items = fs3.readdirSync(dir);
       for (const item of items) {
-        const fullPath = path.join(dir, item);
+        const fullPath = path6.join(dir, item);
         const stat = fs3.statSync(fullPath);
         if (stat.isDirectory()) {
           files = files.concat(getAllFiles(fullPath));
@@ -505,7 +510,7 @@ var LocalArtifactServer = class {
       let files = [];
       const items = fs3.readdirSync(dir);
       for (const item of items) {
-        const fullPath = path.join(dir, item);
+        const fullPath = path6.join(dir, item);
         const stat = fs3.statSync(fullPath);
         if (stat.isDirectory()) {
           files = files.concat(getAllFiles(fullPath));
@@ -573,24 +578,22 @@ var LocalRegistryClient = class {
     if (!manifest) {
       throw new Error("Manifest not found");
     }
-    return this.artifactServer.updateManifestArtifacts(manifest);
+    return this.artifactServer.updateManifestArtifact(manifest);
   }
   async submitAppManifest(manifest) {
     if (!this.validateManifest(manifest)) {
       throw new Error("Invalid manifest structure");
     }
     const processedManifest = await this.processManifestArtifacts(manifest);
-    const manifestKey = `${manifest.app.app_id}/${manifest.version.semver}`;
+    const manifestKey = `${processedManifest.id}/${processedManifest.version}`;
     this.dataStore.setManifest(manifestKey, processedManifest);
-    const appKey = manifest.app.app_id;
     const appSummary = {
-      name: manifest.app.name,
-      developer_pubkey: manifest.app.developer_pubkey,
-      latest_version: manifest.version.semver,
-      latest_cid: manifest.artifacts[0]?.cid || "",
-      alias: manifest.app.alias
+      id: processedManifest.id,
+      name: processedManifest.name,
+      latest_version: processedManifest.version,
+      latest_digest: processedManifest.artifact.digest
     };
-    this.dataStore.setApp(appKey, appSummary);
+    this.dataStore.setApp(processedManifest.id, appSummary);
     return {
       success: true,
       message: "App version registered successfully"
@@ -600,39 +603,33 @@ var LocalRegistryClient = class {
     return { status: "ok" };
   }
   validateManifest(manifest) {
-    return !!(manifest.manifest_version && manifest.app && manifest.app.name && manifest.app.developer_pubkey && manifest.version && manifest.version.semver && manifest.artifacts && manifest.artifacts.length > 0);
+    return !!(manifest.manifest_version && manifest.id && manifest.name && manifest.version && manifest.artifact && manifest.artifact.type && manifest.artifact.target && manifest.artifact.digest && manifest.artifact.uri);
   }
   async processManifestArtifacts(manifest) {
     const processedManifest = { ...manifest };
-    if (processedManifest.artifacts) {
-      processedManifest.artifacts = await Promise.all(
-        processedManifest.artifacts.map(async (artifact) => {
-          const processedArtifact = { ...artifact };
-          if (artifact.path && fs3.existsSync(artifact.path)) {
-            const filename = path.basename(artifact.path);
-            const appId = manifest.app.id || manifest.app.name?.replace(/\s+/g, "-").toLowerCase();
-            try {
-              await this.artifactServer.copyArtifactToLocal(
-                artifact.path,
-                appId,
-                manifest.version.semver,
-                filename
-              );
-              processedArtifact.mirrors = [
-                this.artifactServer.getArtifactUrl(
-                  appId,
-                  manifest.version.semver,
-                  filename
-                )
-              ];
-              delete processedArtifact.path;
-            } catch (error) {
-              console.warn(`Failed to copy artifact ${artifact.path}:`, error);
-            }
-          }
-          return processedArtifact;
-        })
-      );
+    if (manifest.artifact?.uri?.startsWith("file://")) {
+      const filePath = manifest.artifact.uri.replace("file://", "");
+      if (fs3.existsSync(filePath)) {
+        const filename = path6.basename(filePath);
+        try {
+          await this.artifactServer.copyArtifactToLocal(
+            filePath,
+            manifest.id,
+            manifest.version,
+            filename
+          );
+          processedManifest.artifact = {
+            ...manifest.artifact,
+            uri: this.artifactServer.getArtifactUrl(
+              manifest.id,
+              manifest.version,
+              filename
+            )
+          };
+        } catch (error) {
+          console.warn(`Failed to copy artifact ${filePath}:`, error);
+        }
+      }
     }
     return processedManifest;
   }
@@ -648,7 +645,7 @@ function createRegistryClient(useLocal, baseURL, timeout) {
   }
 }
 var appsCommand = new Command("apps").description("Manage SSApp applications").addCommand(
-  new Command("list").description("List all applications").option("-d, --dev <pubkey>", "Filter by developer public key").option("-n, --name <name>", "Filter by application name").action(async (options, command) => {
+  new Command("list").description("List all applications").option("-n, --name <name>", "Filter by application name").action(async (options, command) => {
     const globalOpts = command.parent?.parent?.opts();
     const useLocal = globalOpts?.local || false;
     const client = createRegistryClient(
@@ -659,7 +656,6 @@ var appsCommand = new Command("apps").description("Manage SSApp applications").a
     const spinner2 = ora6("Fetching applications...").start();
     try {
       const apps = await client.getApps({
-        dev: options.dev,
         name: options.name
       });
       spinner2.succeed(`Found ${apps.length} application(s)`);
@@ -668,13 +664,13 @@ var appsCommand = new Command("apps").description("Manage SSApp applications").a
         return;
       }
       const tableData = [
-        ["Name", "Developer", "Latest Version", "Latest CID", "Alias"],
+        ["ID", "Name", "Latest Version", "Digest"],
         ...apps.map((app) => [
+          app.id,
           app.name,
-          app.developer_pubkey?.substring(0, 12) + "..." || "Unknown",
-          app.latest_version || "Unknown",
-          app.latest_cid?.substring(0, 12) + "..." || "N/A",
-          app.alias || "-"
+          app.latest_version,
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          (app.latest_digest || app.latest_cid || "N/A").toString().substring(0, 12) + "..."
         ])
       ];
       console.log(table(tableData));
@@ -756,7 +752,7 @@ var appsCommand = new Command("apps").description("Manage SSApp applications").a
     );
     const spinner2 = ora6("Reading manifest file...").start();
     try {
-      const manifestPath = path.resolve(manifestFile);
+      const manifestPath = path6.resolve(manifestFile);
       if (!fs3.existsSync(manifestPath)) {
         spinner2.fail("Manifest file not found");
         console.error(chalk5.red(`File not found: ${manifestFile}`));
@@ -1072,54 +1068,6 @@ var LocalRegistryServer = class {
         totalSize: artifactStats.totalSize
       };
     });
-    this.server.get("/apps", async (request) => {
-      const query = request.query;
-      return this.dataStore.getApps(query);
-    });
-    this.server.get("/apps/:appId", async (request) => {
-      const { appId } = request.params;
-      return this.dataStore.getAppVersions(appId);
-    });
-    this.server.get("/apps/:appId/:semver", async (request) => {
-      const { appId, semver } = request.params;
-      const manifest = this.dataStore.getManifest(appId, semver);
-      if (!manifest) {
-        return {
-          statusCode: 404,
-          error: "Not Found",
-          message: "Manifest not found"
-        };
-      }
-      return this.artifactServer.updateManifestArtifacts(manifest);
-    });
-    this.server.post("/apps", async (request) => {
-      const manifest = request.body;
-      if (!this.validateManifest(manifest)) {
-        return {
-          statusCode: 400,
-          error: "Bad Request",
-          message: "Invalid manifest structure"
-        };
-      }
-      const processedManifest = await this.processManifestArtifacts(manifest);
-      const manifestKey = `${manifest.app.app_id}/${manifest.version.semver}`;
-      this.dataStore.setManifest(manifestKey, processedManifest);
-      const appKey = manifest.app.app_id;
-      const appSummary = {
-        name: manifest.app.name,
-        developer_pubkey: manifest.app.developer_pubkey,
-        latest_version: manifest.version.semver,
-        latest_cid: manifest.artifacts[0]?.cid || "",
-        alias: manifest.app.name
-        // Use name as alias
-      };
-      this.dataStore.setApp(appKey, appSummary);
-      return {
-        success: true,
-        message: "App version registered successfully",
-        manifest_key: manifestKey
-      };
-    });
     this.server.get(
       "/artifacts/:appId/:version/:filename",
       async (request, reply) => {
@@ -1180,180 +1128,109 @@ var LocalRegistryServer = class {
       await this.seed();
       return { message: "Sample data seeded successfully" };
     });
-    this.server.post("/v1/apps", async (request, reply) => {
-      const manifest = request.body;
-      if (!manifest.manifest_version || !manifest.id || !manifest.name || !manifest.version) {
-        return reply.code(400).send({
-          error: "invalid_schema",
-          details: "Missing required fields"
-        });
-      }
-      try {
-        const processedManifest = await this.processManifestArtifacts(manifest);
-        const manifestKey = `${manifest.id}/${manifest.version}`;
-        this.dataStore.setManifest(manifestKey, processedManifest);
-        const appKey = manifest.id;
-        const appSummary = {
-          id: manifest.id,
-          name: manifest.name,
-          developer_pubkey: "local-dev-key",
-          latest_version: manifest.version,
-          latest_cid: manifest.artifact?.digest || ""
-        };
-        this.dataStore.setApp(appKey, appSummary);
-        return reply.code(201).send({
-          id: manifest.id,
-          version: manifest.version,
-          canonical_uri: `/v1/apps/${manifest.id}/${manifest.version}`
-        });
-      } catch {
-        return reply.code(409).send({
-          error: "already_exists",
-          details: `${manifest.id}@${manifest.version}`
-        });
-      }
-    });
-    this.server.get("/v1/apps/:id", async (request, reply) => {
-      const { id } = request.params;
-      const versions = this.dataStore.getAppVersions(id);
-      if (!versions || versions.length === 0) {
-        return reply.code(404).send({ error: "not_found", message: "App not found" });
-      }
-      return {
-        id,
-        versions: versions.map((v) => v.semver)
-      };
-    });
-    this.server.get("/v1/apps/:id/:version", async (request, reply) => {
-      const { id, version } = request.params;
-      const { canonical } = request.query;
-      const oldManifest = this.dataStore.getManifest(id, version);
-      if (!oldManifest) {
-        return reply.code(404).send({ error: "not_found", message: "Manifest not found" });
-      }
-      const v1Manifest = {
-        manifest_version: oldManifest.manifest_version,
-        id: oldManifest.app.app_id,
-        name: oldManifest.app.name,
-        version: oldManifest.version.semver,
-        chains: oldManifest.supported_chains,
-        artifact: oldManifest.artifacts[0] ? {
-          type: oldManifest.artifacts[0].type,
-          target: oldManifest.artifacts[0].target,
-          digest: oldManifest.artifacts[0].cid || `sha256:${"0".repeat(64)}`,
-          uri: oldManifest.artifacts[0].path || oldManifest.artifacts[0].mirrors?.[0] || "https://example.com/artifact"
-        } : {
-          type: "wasm",
-          target: "node",
-          digest: `sha256:${"0".repeat(64)}`,
-          uri: "https://example.com/artifact"
-        },
-        _warnings: []
-      };
-      if (canonical === "true") {
-        const canonicalJCS = JSON.stringify(
-          v1Manifest,
-          Object.keys(v1Manifest).sort()
-        );
-        return {
-          canonical_jcs: Buffer.from(canonicalJCS, "utf8").toString("base64")
-        };
+    this.server.get("/api/v2/bundles", async (request, reply) => {
+      const query = request.query;
+      const { package: pkg, version, developer } = query;
+      if (pkg && version) {
+        const manifest = this.dataStore.getBundleManifest(pkg, version);
+        if (!manifest) {
+          return reply.code(404).send({
+            error: "bundle_not_found",
+            message: `Bundle ${pkg}@${version} not found`
+          });
+        }
+        return [manifest];
       }
-      return v1Manifest;
-    });
-    this.server.get("/v1/search", async (request, reply) => {
-      const { q } = request.query;
-      if (!q) {
-        return reply.code(400).send({
-          error: "bad_request",
-          message: 'Query parameter "q" is required'
-        });
+      const allBundles = this.dataStore.getAllBundles();
+      const bundles = [];
+      for (const bundle of allBundles) {
+        if (pkg && bundle.package !== pkg) {
+          continue;
+        }
+        if (developer) {
+          const bundlePubkey = bundle.signature?.pubkey;
+          if (!bundlePubkey || bundlePubkey !== developer) {
+            continue;
+          }
+        }
+        bundles.push(bundle);
       }
-      const apps = this.dataStore.getApps({});
-      const results = apps.filter(
-        (app) => app.name.toLowerCase().includes(q.toLowerCase()) || app.id?.toLowerCase().includes(q.toLowerCase())
-      );
-      return results.map((app) => ({
-        id: app.id || app.name,
-        versions: [app.latest_version]
-      }));
-    });
-    this.server.post("/v1/resolve", async (request, reply) => {
-      const { root } = request.body;
-      if (!root || !root.id || !root.version) {
-        return reply.code(400).send({
-          error: "bad_request",
-          message: "Root app ID and version are required"
+      bundles.sort((a, b) => {
+        const pkgCompare = a.package.localeCompare(b.package);
+        if (pkgCompare !== 0) return pkgCompare;
+        return b.appVersion.localeCompare(a.appVersion, void 0, {
+          numeric: true
         });
+      });
+      if (pkg) {
+        return bundles;
+      }
+      const latestByPackage = /* @__PURE__ */ new Map();
+      for (const bundle of bundles) {
+        const existing = latestByPackage.get(bundle.package);
+        if (!existing || bundle.appVersion > existing.appVersion) {
+          latestByPackage.set(bundle.package, bundle);
+        }
       }
-      return {
-        plan: [{ action: "install", id: root.id, version: root.version }],
-        satisfies: [],
-        missing: []
-      };
+      return Array.from(latestByPackage.values());
     });
-  }
-  validateManifest(manifest) {
-    return !!(manifest.manifest_version && manifest.app && manifest.app.app_id && manifest.app.name && manifest.app.developer_pubkey && manifest.version && manifest.version.semver && manifest.artifacts && manifest.artifacts.length > 0);
-  }
-  async processManifestArtifacts(manifest) {
-    const processedManifest = { ...manifest };
-    if (manifest.artifact && manifest.artifact.uri) {
-      const artifact = manifest.artifact;
-      if (artifact.uri.startsWith("file://")) {
-        const filePath = artifact.uri.replace("file://", "");
-        if (fs3.existsSync(filePath)) {
-          const filename = path.basename(filePath);
-          const appId = manifest.id;
-          try {
-            await this.artifactServer.copyArtifactToLocal(
-              filePath,
-              appId,
-              manifest.version,
-              filename
-            );
-            processedManifest.artifact = {
-              ...artifact,
-              uri: this.artifactServer.getArtifactUrl(
-                appId,
-                manifest.version,
-                filename
-              )
-            };
-          } catch (error) {
-            console.warn(`Failed to copy artifact ${filePath}:`, error);
-          }
+    this.server.get(
+      "/api/v2/bundles/:package/:version",
+      async (request, reply) => {
+        const { package: pkg, version } = request.params;
+        const manifest = this.dataStore.getBundleManifest(pkg, version);
+        if (!manifest) {
+          return reply.code(404).send({
+            error: "manifest_not_found",
+            message: `Manifest not found for ${pkg}@${version}`
+          });
         }
+        return manifest;
       }
-    }
-    return processedManifest;
+    );
   }
 };
 var localCommand = new Command("local").description(
   "Manage local registry for development"
 );
 localCommand.addCommand(
-  new Command("start").description("Start local registry server").option("-p, --port <port>", "Port to run the server on", "8082").option("-h, --host <host>", "Host to bind the server to", "localhost").action(async (options) => {
+  new Command("start").description("Start local registry server").option("-p, --port <port>", "Port to run the server on", "8082").option("-h, --host <host>", "Host to bind the server to", "0.0.0.0").option(
+    "--public-host <host>",
+    "Public host exposed in manifest artifact URLs",
+    "host.docker.internal"
+  ).action(async (options) => {
     const spinner2 = ora6("Starting local registry...").start();
     try {
       const config = new LocalConfig();
+      config.setHost(options.host);
+      config.setPublicHost(options.publicHost);
+      config.setPort(parseInt(options.port, 10));
       const server = new LocalRegistryServer(config);
       await server.start(parseInt(options.port));
       spinner2.succeed(
-        `Local registry started on http://${options.host}:${options.port}`
+        `Local registry started on http://${config.getHost()}:${config.getPort()}`
       );
       console.log(chalk5.blue("\n\u{1F4F1} Local Registry Status:"));
       console.log(
-        chalk5.green(`\u2705 Server: http://${options.host}:${options.port}`)
+        chalk5.green(
+          `\u2705 Server: http://${config.getHost()}:${config.getPort()}`
+        )
+      );
+      console.log(
+        chalk5.green(
+          `\u{1F310} Public URL: http://${config.getPublicHost()}:${config.getPort()}`
+        )
       );
       console.log(chalk5.green(`\u{1F4C1} Data: ${config.getDataDir()}`));
       console.log(
         chalk5.green(
-          `\u{1F4CB} Health: http://${options.host}:${options.port}/healthz`
+          `\u{1F4CB} Health: http://${config.getHost()}:${config.getPort()}/healthz`
         )
       );
       console.log(
-        chalk5.green(`\u{1F4CA} Stats: http://${options.host}:${options.port}/stats`)
+        chalk5.green(
+          `\u{1F4CA} Stats: http://${config.getHost()}:${config.getPort()}/stats`
+        )
       );
       console.log(
         chalk5.blue(
@@ -1509,271 +1386,245 @@ localCommand.addCommand(
     }
   })
 );
-var v1Command = new Command("v1").description("V1 API commands for Calimero SSApp Registry").addCommand(createPushCommand()).addCommand(createGetCommand()).addCommand(createListCommand()).addCommand(createResolveCommand()).addCommand(createVerifyCommand());
-function createPushCommand() {
-  return new Command("push").description("Submit a v1 manifest to the registry").argument("<manifest-file>", "Path to manifest JSON file").option("--local", "Use local registry").action(
-    async (manifestFile, options = {}, command) => {
-      try {
-        const globalOpts = command.parent?.parent?.opts();
-        const useLocal = globalOpts?.local || options.local || false;
-        if (!fs3.existsSync(manifestFile)) {
-          console.error(`\u274C Manifest file not found: ${manifestFile}`);
-          process.exit(1);
-        }
-        const manifestContent = fs3.readFileSync(manifestFile, "utf8");
-        const manifest = JSON.parse(manifestContent);
-        if (manifest.manifest_version !== "1.0") {
-          console.error('\u274C Invalid manifest version. Must be "1.0"');
-          process.exit(1);
-        }
-        if (!manifest.id || !manifest.name || !manifest.version) {
-          console.error("\u274C Missing required fields: id, name, version");
-          process.exit(1);
-        }
-        const baseUrl = useLocal ? "http://localhost:8082" : "http://localhost:8080";
-        console.log(
-          `\u{1F4E4} Submitting manifest: ${manifest.id}@${manifest.version}`
-        );
-        console.log(`   Name: ${manifest.name}`);
-        console.log(`   Chains: ${manifest.chains?.join(", ")}`);
-        console.log(
-          `   Provides: ${manifest.provides?.join(", ") || "none"}`
-        );
-        console.log(
-          `   Requires: ${manifest.requires?.join(", ") || "none"}`
-        );
-        const response = await fetch(`${baseUrl}/v1/apps`, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(manifest)
-        });
-        if (!response.ok) {
-          const error = await response.json();
-          throw new Error(`${error.error}: ${error.details}`);
-        }
-        const result = await response.json();
-        console.log("\u2705 Manifest submitted successfully!");
-        console.log(`   ID: ${result.id}`);
-        console.log(`   Version: ${result.version}`);
-        console.log(`   URI: ${result.canonical_uri}`);
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        console.error("\u274C Failed to submit manifest:", errorMessage);
-        process.exit(1);
-      }
+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(
+    "--export <interface>",
+    "Export interface (can be specified multiple times)",
+    (value, prev) => {
+      return [...prev || [], value];
     }
-  );
-}
-function createGetCommand() {
-  return new Command("get").description("Get manifest from registry").argument("<app-id>", "Application ID").argument("[version]", "Specific version (optional)").option("--local", "Use local registry").option("--canonical", "Return canonical JCS format").action(
-    async (appId, version, options = {}, command) => {
-      try {
-        const globalOpts = command.parent?.parent?.opts();
-        const useLocal = globalOpts?.local || options.local || false;
-        const baseUrl = useLocal ? "http://localhost:8082" : "http://localhost:8080";
-        if (version) {
-          console.log(`\u{1F4E5} Getting manifest: ${appId}@${version}`);
-          const url = options.canonical ? `/v1/apps/${appId}/${version}?canonical=true` : `/v1/apps/${appId}/${version}`;
-          const response = await fetch(`${baseUrl}${url}`);
-          if (!response.ok) {
-            if (response.status === 404) {
-              console.error(`\u274C Manifest not found: ${appId}@${version}`);
-            } else {
-              console.error(
-                `\u274C Error: ${response.status} ${response.statusText}`
-              );
-            }
-            process.exit(1);
-          }
-          const manifest = await response.json();
-          console.log(JSON.stringify(manifest, null, 2));
-        } else {
-          console.log(`\u{1F4E5} Getting versions for: ${appId}`);
-          const response = await fetch(`${baseUrl}/v1/apps/${appId}`);
-          if (!response.ok) {
-            if (response.status === 404) {
-              console.error(`\u274C App not found: ${appId}`);
-            } else {
-              console.error(
-                `\u274C Error: ${response.status} ${response.statusText}`
-              );
-            }
-            process.exit(1);
-          }
-          const result = await response.json();
-          console.log(`\u{1F4F1} App: ${result.id}`);
-          console.log(`\u{1F4CB} Versions: ${result.versions.join(", ")}`);
-        }
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        console.error("\u274C Failed to get manifest:", errorMessage);
+  ).option(
+    "--use <interface>",
+    "Use interface (can be specified multiple times)",
+    (value, prev) => {
+      return [...prev || [], value];
+    }
+  ).action(async (wasmFile, pkg, version, options) => {
+    try {
+      const wasmPath = path6.resolve(wasmFile);
+      if (!fs3.existsSync(wasmPath)) {
+        console.error(`\u274C WASM file not found: ${wasmFile}`);
         process.exit(1);
       }
-    }
-  );
-}
-function createListCommand() {
-  return new Command("ls").description("List applications in registry").option("--local", "Use local registry").option("--search <query>", "Search query").action(
-    async (options = {}, command) => {
-      try {
-        const globalOpts = command.parent?.parent?.opts();
-        const useLocal = globalOpts?.local || options.local || false;
-        const baseUrl = useLocal ? "http://localhost:8082" : "http://localhost:8080";
-        if (options.search) {
-          console.log(`\u{1F50D} Searching for: ${options.search}`);
-          const response = await fetch(
-            `${baseUrl}/v1/search?q=${encodeURIComponent(options.search)}`
-          );
-          if (!response.ok) {
-            console.error(
-              `\u274C Error: ${response.status} ${response.statusText}`
-            );
-            process.exit(1);
-          }
-          const results = await response.json();
-          if (results.length === 0) {
-            console.log("No results found");
-            return;
-          }
-          console.log(`Found ${results.length} result(s):`);
-          results.forEach((result) => {
-            console.log(
-              `  \u{1F4F1} ${result.id}@${result.versions?.[0] || "unknown"}`
-            );
-            if (result.provides?.length > 0) {
-              console.log(`     Provides: ${result.provides.join(", ")}`);
-            }
-            if (result.requires?.length > 0) {
-              console.log(`     Requires: ${result.requires.join(", ")}`);
-            }
-          });
-        } else {
-          console.log("\u{1F4CB} Listing all applications...");
-          console.log(
-            "Note: Use --search <query> to search for specific apps"
-          );
+      console.log(`\u{1F4E6} Creating MPK bundle from: ${path6.basename(wasmPath)}`);
+      const wasmContent = fs3.readFileSync(wasmPath);
+      const wasmSize = wasmContent.length;
+      const hash = crypto.createHash("sha256").update(wasmContent).digest("hex");
+      const metadata = {
+        name: options.name || pkg,
+        description: options.description || "",
+        author: options.author || "Calimero Team"
+      };
+      const links = {};
+      if (options.frontend) links.frontend = options.frontend;
+      if (options.github) links.github = options.github;
+      if (options.docs) links.docs = options.docs;
+      const interfaces = {
+        exports: options.export || [],
+        uses: options.use || []
+      };
+      const manifest = {
+        version: "1.0",
+        package: pkg,
+        appVersion: version,
+        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,
+          size: wasmSize
+        },
+        abi: null,
+        migrations: [],
+        links: Object.keys(links).length > 0 ? links : void 0,
+        signature: void 0
+      };
+      let outputPath = options.output;
+      if (!outputPath) {
+        const outputDir = path6.join(process.cwd(), pkg, version);
+        if (!fs3.existsSync(outputDir)) {
+          fs3.mkdirSync(outputDir, { recursive: true });
+        }
+        outputPath = path6.join(outputDir, `${pkg}-${version}.mpk`);
+      } else {
+        outputPath = path6.resolve(outputPath);
+        const outputDir = path6.dirname(outputPath);
+        if (!fs3.existsSync(outputDir)) {
+          fs3.mkdirSync(outputDir, { recursive: true });
         }
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        console.error("\u274C Failed to list applications:", errorMessage);
-        process.exit(1);
       }
-    }
-  );
-}
-function createResolveCommand() {
-  return new Command("resolve").description("Resolve dependencies for an application").argument("<app-id>", "Application ID").argument("<version>", "Application version").option("--local", "Use local registry").action(
-    async (appId, version, options = {}, command) => {
+      const tempDir = path6.join(
+        path6.dirname(outputPath),
+        `.temp-bundle-${Date.now()}`
+      );
+      fs3.mkdirSync(tempDir, { recursive: true });
       try {
-        const globalOpts = command.parent?.parent?.opts();
-        const useLocal = globalOpts?.local || options.local || false;
-        const baseUrl = useLocal ? "http://localhost:8082" : "http://localhost:8080";
-        console.log(`\u{1F50D} Resolving dependencies for: ${appId}@${version}`);
-        const resolveRequest = {
-          root: { id: appId, version },
-          installed: []
-          // Could be extended to support pre-installed apps
-        };
-        const response = await fetch(`${baseUrl}/v1/resolve`, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(resolveRequest)
-        });
-        if (!response.ok) {
-          const error = await response.json();
-          console.error(`\u274C Resolution failed: ${error.error}`);
-          console.error(`   Details: ${error.details}`);
-          process.exit(1);
-        }
-        const result = await response.json();
-        console.log("\u2705 Dependencies resolved successfully!");
-        console.log(`\u{1F4CB} Installation plan:`);
-        result.plan.forEach(
-          (item) => {
-            console.log(`   ${item.action}: ${item.id}@${item.version}`);
-          }
+        fs3.writeFileSync(
+          path6.join(tempDir, "manifest.json"),
+          JSON.stringify(manifest, null, 2)
         );
-        if (result.satisfies?.length > 0) {
-          console.log(`\u2705 Satisfies: ${result.satisfies.join(", ")}`);
-        }
-        if (result.missing?.length > 0) {
-          console.log(`\u274C Missing: ${result.missing.join(", ")}`);
+        fs3.writeFileSync(path6.join(tempDir, "app.wasm"), wasmContent);
+        await tar.create(
+          {
+            gzip: true,
+            file: outputPath,
+            cwd: tempDir
+          },
+          ["manifest.json", "app.wasm"]
+        );
+        const outputSize = fs3.statSync(outputPath).size;
+        console.log(`\u2705 Created MPK bundle: ${outputPath}`);
+        console.log(`   Package: ${pkg}`);
+        console.log(`   Version: ${version}`);
+        console.log(`   Size: ${outputSize} bytes`);
+        console.log(`   WASM Hash: ${hash}`);
+      } finally {
+        if (fs3.existsSync(tempDir)) {
+          fs3.rmSync(tempDir, { recursive: true, force: true });
         }
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        console.error("\u274C Failed to resolve dependencies:", errorMessage);
-        process.exit(1);
       }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      console.error("\u274C Failed to create bundle:", message);
+      process.exit(1);
     }
-  );
+  });
 }
-function createVerifyCommand() {
-  return new Command("verify").description("Verify manifest signature and integrity").argument("<manifest-file>", "Path to manifest JSON file").action(async (manifestFile) => {
+function createPushCommand() {
+  return new Command("push").description("Push a bundle (.mpk) to the registry").argument("<bundle-file>", "Path to the .mpk bundle file").option("--local", "Push to local registry instance", true).action(async (bundleFile, options) => {
     try {
-      if (!fs3.existsSync(manifestFile)) {
-        console.error(`\u274C Manifest file not found: ${manifestFile}`);
+      const fullPath = path6.resolve(bundleFile);
+      if (!fs3.existsSync(fullPath)) {
+        console.error(`\u274C File not found: ${bundleFile}`);
         process.exit(1);
       }
-      const manifestContent = fs3.readFileSync(manifestFile, "utf8");
-      const manifest = JSON.parse(manifestContent);
-      console.log(
-        `\u{1F50D} Verifying manifest: ${manifest.id}@${manifest.version}`
-      );
-      if (manifest.manifest_version !== "1.0") {
-        console.error("\u274C Invalid manifest version");
-        process.exit(1);
-      }
-      const requiredFields = ["id", "name", "version", "chains", "artifact"];
-      const missingFields = requiredFields.filter(
-        (field) => !manifest[field]
-      );
-      if (missingFields.length > 0) {
-        console.error(
-          `\u274C Missing required fields: ${missingFields.join(", ")}`
-        );
+      console.log(`\u{1F4E6} Processing bundle: ${path6.basename(fullPath)}`);
+      const manifest = await extractManifest(fullPath);
+      if (!manifest) {
+        console.error("\u274C manifest.json not found in bundle");
         process.exit(1);
       }
-      if (manifest.artifact.type !== "wasm" || manifest.artifact.target !== "node") {
-        console.error("\u274C Invalid artifact type or target");
+      if (!manifest.package || !manifest.appVersion) {
+        console.error("\u274C Invalid manifest: missing package or appVersion");
         process.exit(1);
       }
-      if (!manifest.artifact.digest.match(/^sha256:[0-9a-f]{64}$/)) {
-        console.error("\u274C Invalid artifact digest format");
+      console.log(`   Package: ${manifest.package}`);
+      console.log(`   Version: ${manifest.appVersion}`);
+      if (manifest.metadata) {
+        console.log(`   Name: ${manifest.metadata.name}`);
+      }
+      if (options.local) {
+        const config = new LocalConfig();
+        const store = new LocalDataStore(config);
+        const artifactServer = new LocalArtifactServer(config, store);
+        const bundleFilename = `${manifest.package}-${manifest.appVersion}.mpk`;
+        const targetPath = await artifactServer.copyArtifactToLocal(
+          fullPath,
+          manifest.package,
+          manifest.appVersion,
+          bundleFilename
+        );
+        console.log(`   Artifact stored: ${targetPath}`);
+        store.setBundleManifest(
+          manifest.package,
+          manifest.appVersion,
+          manifest
+        );
+        console.log("\u2705 Bundle manifest registered locally");
+        console.log(
+          `   Run 'calimero-registry bundle get ${manifest.package} ${manifest.appVersion}' to verify`
+        );
+      } else {
+        console.error("\u274C Remote push not implemented yet");
         process.exit(1);
       }
-      if (!manifest.artifact.uri.match(/^(https:\/\/|ipfs:\/\/)/)) {
-        console.error("\u274C Invalid artifact URI format");
+    } catch (error) {
+      console.error("\u274C Failed to push bundle:", error);
+      process.exit(1);
+    }
+  });
+}
+function createGetCommand() {
+  return new Command("get").description("Get bundle manifest").argument("<package>", "Package name (e.g. com.calimero.kv)").argument("<version>", "Version (e.g. 1.0.0)").option("--local", "Use local registry", true).action(async (pkg, version, options) => {
+    try {
+      if (options.local) {
+        const config = new LocalConfig();
+        const store = new LocalDataStore(config);
+        const manifest = store.getBundleManifest(pkg, version);
+        if (manifest) {
+          console.log(JSON.stringify(manifest, null, 2));
+        } else {
+          console.error(`\u274C Manifest not found: ${pkg}@${version}`);
+          process.exit(1);
+        }
+      } else {
+        console.error("\u274C Remote get not implemented yet");
         process.exit(1);
       }
-      if (manifest.signature) {
-        console.log("\u{1F510} Verifying signature...");
-        console.log("\u26A0\uFE0F  Signature verification not implemented in CLI yet");
-      }
-      console.log("\u2705 Manifest verification passed!");
-      console.log(`   ID: ${manifest.id}`);
-      console.log(`   Name: ${manifest.name}`);
-      console.log(`   Version: ${manifest.version}`);
-      console.log(`   Chains: ${manifest.chains.join(", ")}`);
-      console.log(`   Artifact: ${manifest.artifact.uri}`);
-      if (manifest.provides?.length > 0) {
-        console.log(`   Provides: ${manifest.provides.join(", ")}`);
-      }
-      if (manifest.requires?.length > 0) {
-        console.log(`   Requires: ${manifest.requires.join(", ")}`);
-      }
     } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      console.error("\u274C Failed to verify manifest:", errorMessage);
+      console.error("\u274C Error:", error);
       process.exit(1);
     }
   });
 }
+async function extractManifest(bundlePath) {
+  let manifestContent = null;
+  await tar.t({
+    file: bundlePath,
+    onentry: (entry) => {
+      if (entry.path === "manifest.json") ;
+    }
+  });
+  const extractDir = path6.join(path6.dirname(bundlePath), `.temp-${Date.now()}`);
+  if (!fs3.existsSync(extractDir)) {
+    fs3.mkdirSync(extractDir);
+  }
+  try {
+    await tar.x({
+      file: bundlePath,
+      cwd: extractDir,
+      filter: (path7) => path7 === "manifest.json"
+    });
+    const manifestPath = path6.join(extractDir, "manifest.json");
+    if (fs3.existsSync(manifestPath)) {
+      const content = fs3.readFileSync(manifestPath, "utf8");
+      manifestContent = content;
+    }
+  } catch {
+  } finally {
+    if (fs3.existsSync(extractDir)) {
+      fs3.rmSync(extractDir, { recursive: true, force: true });
+    }
+  }
+  if (manifestContent) {
+    try {
+      return JSON.parse(manifestContent);
+    } catch {
+      console.error("Failed to parse manifest JSON");
+      return null;
+    }
+  }
+  return null;
+}
 
 // src/index.ts
 var program = new Command();
 program.name("calimero-registry").description(
   "Calimero Network App Registry CLI - Command-line interface for the App Registry"
 ).version("1.0.0");
+program.addHelpText(
+  "after",
+  `
+Examples:
+  $ calimero-registry apps list
+  $ calimero-registry apps create --file manifest.json
+  $ calimero-registry local start
+  $ calimero-registry health --local
+
+For more information, visit: https://github.com/calimero-network/app-registry
+`
+);
 program.option("-u, --url <url>", "Registry API URL", "http://localhost:8082");
 program.option(
   "-t, --timeout <timeout>",
@@ -1787,7 +1638,7 @@ program.addCommand(attestationsCommand);
 program.addCommand(healthCommand);
 program.addCommand(ipfsCommand);
 program.addCommand(localCommand);
-program.addCommand(v1Command);
+program.addCommand(bundleCommand);
 program.exitOverride();
 try {
   program.parse();