@calimero-network/registry-cli 1.0.0 → 1.2.0

package/dist/index.js

@@ -1,20 +1,662 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
-import chalk from 'chalk';
-import ora from 'ora';
+import chalk5 from 'chalk';
+import ora6 from 'ora';
 import { table } from 'table';
 import { SSAppRegistryClient } from '@calimero-network/registry-client';
-import fs, { existsSync, writeFileSync } from 'fs';
+import fs3, { existsSync, writeFileSync } from 'fs';
 import path 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';
 
+var LocalConfig = class {
+  constructor() {
+    this.configPath = path.join(
+      os.homedir(),
+      ".calimero-registry",
+      "config.json"
+    );
+    this.dataDir = path.join(os.homedir(), ".calimero-registry");
+    this.config = this.loadConfig();
+  }
+  loadConfig() {
+    const defaultConfig = {
+      server: {
+        port: 8082,
+        host: "localhost"
+      },
+      data: {
+        dir: path.join(os.homedir(), ".calimero-registry", "data"),
+        artifactsDir: path.join(
+          os.homedir(),
+          ".calimero-registry",
+          "artifacts"
+        )
+      },
+      artifacts: {
+        storageDir: path.join(os.homedir(), ".calimero-registry", "artifacts"),
+        serveLocal: true,
+        copyArtifacts: true,
+        maxFileSize: "100MB",
+        allowedTypes: ["wasm", "js", "html"]
+      }
+    };
+    if (fs3.existsSync(this.configPath)) {
+      try {
+        const existingConfig = JSON.parse(
+          fs3.readFileSync(this.configPath, "utf8")
+        );
+        return { ...defaultConfig, ...existingConfig };
+      } catch {
+        console.warn("Failed to load existing config, using defaults");
+      }
+    }
+    return defaultConfig;
+  }
+  saveConfig() {
+    const configDir = path.dirname(this.configPath);
+    if (!fs3.existsSync(configDir)) {
+      fs3.mkdirSync(configDir, { recursive: true });
+    }
+    fs3.writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));
+  }
+  // Server configuration
+  getPort() {
+    return this.config.server.port;
+  }
+  setPort(port) {
+    this.config.server.port = port;
+    this.saveConfig();
+  }
+  getHost() {
+    return this.config.server.host;
+  }
+  setHost(host) {
+    this.config.server.host = 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.saveConfig();
+  }
+  getArtifactsDir() {
+    return this.config.data.artifactsDir;
+  }
+  setArtifactsDir(dir) {
+    this.config.data.artifactsDir = dir;
+    this.config.artifacts.storageDir = dir;
+    this.saveConfig();
+  }
+  // Artifact configuration
+  getArtifactsConfig() {
+    return this.config.artifacts;
+  }
+  setArtifactsConfig(config) {
+    this.config.artifacts = { ...this.config.artifacts, ...config };
+    this.saveConfig();
+  }
+  // Utility methods
+  ensureDirectories() {
+    const dirs = [
+      this.getDataDir(),
+      this.getArtifactsDir(),
+      path.join(this.getDataDir(), "backups"),
+      path.join(this.getDataDir(), "logs")
+    ];
+    dirs.forEach((dir) => {
+      if (!fs3.existsSync(dir)) {
+        fs3.mkdirSync(dir, { recursive: true });
+      }
+    });
+  }
+  getConfigPath() {
+    return this.configPath;
+  }
+  // Get full configuration
+  getConfig() {
+    return { ...this.config };
+  }
+  // Reset to defaults
+  reset() {
+    this.config = {
+      server: {
+        port: 8082,
+        host: "localhost"
+      },
+      data: {
+        dir: path.join(os.homedir(), ".calimero-registry", "data"),
+        artifactsDir: path.join(
+          os.homedir(),
+          ".calimero-registry",
+          "artifacts"
+        )
+      },
+      artifacts: {
+        storageDir: path.join(os.homedir(), ".calimero-registry", "artifacts"),
+        serveLocal: true,
+        copyArtifacts: true,
+        maxFileSize: "100MB",
+        allowedTypes: ["wasm", "js", "html"]
+      }
+    };
+    this.saveConfig();
+  }
+};
+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.data = {
+      apps: /* @__PURE__ */ new Map(),
+      manifests: /* @__PURE__ */ new Map(),
+      artifacts: /* @__PURE__ */ new Map()
+    };
+    this.loadData();
+  }
+  loadData() {
+    try {
+      if (fs3.existsSync(this.appsFile)) {
+        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")
+        );
+        this.data.manifests = new Map(Object.entries(manifestsData));
+      }
+      if (fs3.existsSync(this.artifactsFile)) {
+        const artifactsData = JSON.parse(
+          fs3.readFileSync(this.artifactsFile, "utf8")
+        );
+        this.data.artifacts = new Map(Object.entries(artifactsData));
+      }
+    } catch {
+      console.warn("Failed to load existing data, starting fresh");
+    }
+  }
+  saveData() {
+    try {
+      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);
+      fs3.writeFileSync(
+        this.manifestsFile,
+        JSON.stringify(manifestsObj, null, 2)
+      );
+      const artifactsObj = Object.fromEntries(this.data.artifacts);
+      fs3.writeFileSync(
+        this.artifactsFile,
+        JSON.stringify(artifactsObj, null, 2)
+      );
+    } catch (error) {
+      throw new Error(
+        `Failed to save data: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  // 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));
+    }
+    return apps;
+  }
+  getApp(appKey) {
+    return this.data.apps.get(appKey);
+  }
+  setApp(appKey, app) {
+    this.data.apps.set(appKey, app);
+    this.saveData();
+  }
+  // Versions management
+  getAppVersions(appId) {
+    const versions = [];
+    for (const [key, manifest] of this.data.manifests.entries()) {
+      if (key.startsWith(`${appId}/`)) {
+        const semver = key.split("/").pop();
+        versions.push({
+          semver,
+          cid: manifest.artifacts[0]?.cid || "",
+          yanked: false
+          // TODO: Implement yanking
+        });
+      }
+    }
+    return versions.sort(
+      (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);
+  }
+  setManifest(manifestKey, manifest) {
+    this.data.manifests.set(manifestKey, manifest);
+    this.saveData();
+  }
+  // Artifact management
+  getArtifactPath(hash) {
+    return this.data.artifacts.get(hash);
+  }
+  setArtifactPath(hash, filePath) {
+    this.data.artifacts.set(hash, filePath);
+    this.saveData();
+  }
+  // Statistics
+  getStats() {
+    return {
+      publishedApps: this.data.apps.size,
+      totalVersions: this.data.manifests.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(
+      this.config.getDataDir(),
+      "backups",
+      `backup-${timestamp}.json`
+    );
+    const backupDir = path.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),
+      artifacts: Object.fromEntries(this.data.artifacts)
+    };
+    fs3.writeFileSync(backupPath, JSON.stringify(backupData, null, 2));
+    return backupPath;
+  }
+  async restore(backupPath) {
+    if (!fs3.existsSync(backupPath)) {
+      throw new Error(`Backup file not found: ${backupPath}`);
+    }
+    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.artifacts = new Map(Object.entries(backupData.artifacts || {}));
+    this.saveData();
+  }
+  // Reset data
+  reset() {
+    this.data.apps.clear();
+    this.data.manifests.clear();
+    this.data.artifacts.clear();
+    this.saveData();
+  }
+  // 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"
+      },
+      {
+        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();
+  }
+};
+var LocalArtifactServer = class {
+  constructor(config, dataStore) {
+    this.config = config;
+    this.dataStore = dataStore;
+    this.artifactsDir = config.getArtifactsDir();
+    this.ensureArtifactsDir();
+  }
+  ensureArtifactsDir() {
+    if (!fs3.existsSync(this.artifactsDir)) {
+      fs3.mkdirSync(this.artifactsDir, { recursive: true });
+    }
+  }
+  // Copy artifact to local storage
+  async copyArtifactToLocal(sourcePath, appId, version, filename) {
+    if (!fs3.existsSync(sourcePath)) {
+      throw new Error(`Source file not found: ${sourcePath}`);
+    }
+    const appVersionDir = path.join(this.artifactsDir, appId, version);
+    if (!fs3.existsSync(appVersionDir)) {
+      fs3.mkdirSync(appVersionDir, { recursive: true });
+    }
+    const targetPath = path.join(appVersionDir, filename);
+    fs3.copyFileSync(sourcePath, targetPath);
+    const fileHash = await this.calculateFileHash(targetPath);
+    this.dataStore.setArtifactPath(fileHash, targetPath);
+    return targetPath;
+  }
+  // Serve artifact by app ID, version, and filename
+  async serveArtifact(appId, version, filename) {
+    const artifactPath = path.join(this.artifactsDir, appId, version, filename);
+    if (!fs3.existsSync(artifactPath)) {
+      throw new Error(`Artifact not found: ${artifactPath}`);
+    }
+    return fs3.readFileSync(artifactPath);
+  }
+  // Serve artifact by hash
+  async serveByHash(hash) {
+    const artifactPath = this.dataStore.getArtifactPath(hash);
+    if (!artifactPath || !fs3.existsSync(artifactPath)) {
+      throw new Error(`Artifact not found for hash: ${hash}`);
+    }
+    return fs3.readFileSync(artifactPath);
+  }
+  // Validate artifact file
+  async validateArtifact(filePath) {
+    if (!fs3.existsSync(filePath)) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+    const stats = fs3.statSync(filePath);
+    const fileBuffer = fs3.readFileSync(filePath);
+    const sha256 = crypto.createHash("sha256").update(fileBuffer).digest("hex");
+    return {
+      size: stats.size,
+      sha256
+    };
+  }
+  // Calculate file hash
+  async calculateFileHash(filePath) {
+    const fileBuffer = fs3.readFileSync(filePath);
+    return crypto.createHash("sha256").update(fileBuffer).digest("hex");
+  }
+  // Get artifact URL for local serving
+  getArtifactUrl(appId, version, filename) {
+    const baseUrl = `http://${this.config.getHost()}:${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()}`;
+    return `${baseUrl}/artifacts/${hash}`;
+  }
+  // Update manifest artifacts to use local URLs
+  updateManifestArtifacts(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;
+        }
+      );
+    }
+    return updatedManifest;
+  }
+  // Clean up old artifacts
+  async cleanupOldArtifacts(maxAge = 30 * 24 * 60 * 60 * 1e3) {
+    const now = Date.now();
+    const getAllFiles = (dir) => {
+      let files = [];
+      const items = fs3.readdirSync(dir);
+      for (const item of items) {
+        const fullPath = path.join(dir, item);
+        const stat = fs3.statSync(fullPath);
+        if (stat.isDirectory()) {
+          files = files.concat(getAllFiles(fullPath));
+        } else {
+          files.push(fullPath);
+        }
+      }
+      return files;
+    };
+    const allFiles = getAllFiles(this.artifactsDir);
+    for (const file of allFiles) {
+      const stats = fs3.statSync(file);
+      const age = now - stats.mtime.getTime();
+      if (age > maxAge) {
+        fs3.unlinkSync(file);
+        console.log(`Cleaned up old artifact: ${file}`);
+      }
+    }
+  }
+  // Get artifact statistics
+  getArtifactStats() {
+    let totalFiles = 0;
+    let totalSize = 0;
+    let oldestFile = null;
+    const getAllFiles = (dir) => {
+      let files = [];
+      const items = fs3.readdirSync(dir);
+      for (const item of items) {
+        const fullPath = path.join(dir, item);
+        const stat = fs3.statSync(fullPath);
+        if (stat.isDirectory()) {
+          files = files.concat(getAllFiles(fullPath));
+        } else {
+          files.push(fullPath);
+        }
+      }
+      return files;
+    };
+    if (fs3.existsSync(this.artifactsDir)) {
+      const allFiles = getAllFiles(this.artifactsDir);
+      for (const file of allFiles) {
+        const stats = fs3.statSync(file);
+        totalFiles++;
+        totalSize += stats.size;
+        if (!oldestFile || stats.mtime < oldestFile) {
+          oldestFile = stats.mtime;
+        }
+      }
+    }
+    return {
+      totalFiles,
+      totalSize,
+      oldestFile
+    };
+  }
+};
+var RemoteRegistryClient = class {
+  constructor(baseURL, timeout) {
+    this.client = new SSAppRegistryClient({
+      baseURL,
+      timeout
+    });
+  }
+  async getApps(filters) {
+    return await this.client.getApps(filters);
+  }
+  async getAppVersions(appId) {
+    return await this.client.getAppVersions(appId);
+  }
+  async getAppManifest(appId, semver) {
+    return await this.client.getAppManifest(appId, semver);
+  }
+  async submitAppManifest(manifest) {
+    return await this.client.submitAppManifest(manifest);
+  }
+  async healthCheck() {
+    return await this.client.healthCheck();
+  }
+};
+var LocalRegistryClient = class {
+  constructor() {
+    this.config = new LocalConfig();
+    this.dataStore = new LocalDataStore(this.config);
+    this.artifactServer = new LocalArtifactServer(this.config, this.dataStore);
+  }
+  async getApps(filters) {
+    return this.dataStore.getApps(filters);
+  }
+  async getAppVersions(appId) {
+    return this.dataStore.getAppVersions(appId);
+  }
+  async getAppManifest(appId, semver) {
+    const manifest = this.dataStore.getManifest(appId, semver);
+    if (!manifest) {
+      throw new Error("Manifest not found");
+    }
+    return this.artifactServer.updateManifestArtifacts(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}`;
+    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
+    };
+    this.dataStore.setApp(appKey, appSummary);
+    return {
+      success: true,
+      message: "App version registered successfully"
+    };
+  }
+  async healthCheck() {
+    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);
+  }
+  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;
+        })
+      );
+    }
+    return processedManifest;
+  }
+};
+function createRegistryClient(useLocal, baseURL, timeout) {
+  if (useLocal) {
+    return new LocalRegistryClient();
+  } else {
+    return new RemoteRegistryClient(
+      baseURL || "http://localhost:8082",
+      timeout || 1e4
+    );
+  }
+}
 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) => {
     const globalOpts = command.parent?.parent?.opts();
-    const client = new SSAppRegistryClient({
-      baseURL: globalOpts?.url || "http://localhost:8082",
-      timeout: parseInt(globalOpts?.timeout || "10000")
-    });
-    const spinner2 = ora("Fetching applications...").start();
+    const useLocal = globalOpts?.local || false;
+    const client = createRegistryClient(
+      useLocal,
+      globalOpts?.url,
+      parseInt(globalOpts?.timeout || "10000")
+    );
+    const spinner2 = ora6("Fetching applications...").start();
     try {
       const apps = await client.getApps({
         dev: options.dev,
@@ -22,7 +664,7 @@ var appsCommand = new Command("apps").description("Manage SSApp applications").a
       });
       spinner2.succeed(`Found ${apps.length} application(s)`);
       if (apps.length === 0) {
-        console.log(chalk.yellow("No applications found"));
+        console.log(chalk5.yellow("No applications found"));
         return;
       }
       const tableData = [
@@ -39,7 +681,7 @@ var appsCommand = new Command("apps").description("Manage SSApp applications").a
     } catch (error) {
       spinner2.fail("Failed to fetch applications");
       if (error instanceof Error) {
-        console.error(chalk.red(`Error: ${error.message}`));
+        console.error(chalk5.red(`Error: ${error.message}`));
       }
       process.exit(1);
     }
@@ -47,16 +689,18 @@ var appsCommand = new Command("apps").description("Manage SSApp applications").a
 ).addCommand(
   new Command("versions").description("List versions of a specific application").argument("<appId>", "Application ID").action(async (appId, options, command) => {
     const globalOpts = command.parent?.parent?.opts();
-    const client = new SSAppRegistryClient({
-      baseURL: globalOpts?.url || "http://localhost:8082",
-      timeout: parseInt(globalOpts?.timeout || "10000")
-    });
-    const spinner2 = ora(`Fetching versions for ${appId}...`).start();
+    const useLocal = globalOpts?.local || false;
+    const client = createRegistryClient(
+      useLocal,
+      globalOpts?.url,
+      parseInt(globalOpts?.timeout || "10000")
+    );
+    const spinner2 = ora6(`Fetching versions for ${appId}...`).start();
     try {
       const versions = await client.getAppVersions(appId);
       spinner2.succeed(`Found ${versions.length} version(s)`);
       if (versions.length === 0) {
-        console.log(chalk.yellow("No versions found"));
+        console.log(chalk5.yellow("No versions found"));
         return;
       }
       const tableData = [
@@ -64,14 +708,14 @@ var appsCommand = new Command("apps").description("Manage SSApp applications").a
         ...versions.map((version) => [
           version.semver,
           version.cid.substring(0, 12) + "...",
-          version.yanked ? chalk.red("Yes") : chalk.green("No")
+          version.yanked ? chalk5.red("Yes") : chalk5.green("No")
         ])
       ];
       console.log(table(tableData));
     } catch (error) {
       spinner2.fail("Failed to fetch versions");
       if (error instanceof Error) {
-        console.error(chalk.red(`Error: ${error.message}`));
+        console.error(chalk5.red(`Error: ${error.message}`));
       }
       process.exit(1);
     }
@@ -79,22 +723,24 @@ var appsCommand = new Command("apps").description("Manage SSApp applications").a
 ).addCommand(
   new Command("manifest").description("Get manifest for a specific application version").argument("<appId>", "Application ID").argument("<version>", "Application version").action(async (appId, version, options, command) => {
     const globalOpts = command.parent?.parent?.opts();
-    const client = new SSAppRegistryClient({
-      baseURL: globalOpts?.url || "http://localhost:8082",
-      timeout: parseInt(globalOpts?.timeout || "10000")
-    });
-    const spinner2 = ora(
+    const useLocal = globalOpts?.local || false;
+    const client = createRegistryClient(
+      useLocal,
+      globalOpts?.url,
+      parseInt(globalOpts?.timeout || "10000")
+    );
+    const spinner2 = ora6(
       `Fetching manifest for ${appId}@${version}...`
     ).start();
     try {
       const manifest = await client.getAppManifest(appId, version);
       spinner2.succeed("Manifest fetched successfully");
-      console.log(chalk.blue("\nApplication Manifest:"));
+      console.log(chalk5.blue("\nApplication Manifest:"));
       console.log(JSON.stringify(manifest, null, 2));
     } catch (error) {
       spinner2.fail("Failed to fetch manifest");
       if (error instanceof Error) {
-        console.error(chalk.red(`Error: ${error.message}`));
+        console.error(chalk5.red(`Error: ${error.message}`));
       }
       process.exit(1);
     }
@@ -102,37 +748,39 @@ var appsCommand = new Command("apps").description("Manage SSApp applications").a
 ).addCommand(
   new Command("submit").description("Submit a new application manifest").argument("<manifest-file>", "Path to the manifest JSON file").action(async (manifestFile, options, command) => {
     const globalOpts = command.parent?.parent?.opts();
-    const client = new SSAppRegistryClient({
-      baseURL: globalOpts?.url || "http://localhost:8082",
-      timeout: parseInt(globalOpts?.timeout || "10000")
-    });
-    const spinner2 = ora("Reading manifest file...").start();
+    const useLocal = globalOpts?.local || false;
+    const client = createRegistryClient(
+      useLocal,
+      globalOpts?.url,
+      parseInt(globalOpts?.timeout || "10000")
+    );
+    const spinner2 = ora6("Reading manifest file...").start();
     try {
       const manifestPath = path.resolve(manifestFile);
-      if (!fs.existsSync(manifestPath)) {
+      if (!fs3.existsSync(manifestPath)) {
         spinner2.fail("Manifest file not found");
-        console.error(chalk.red(`File not found: ${manifestFile}`));
+        console.error(chalk5.red(`File not found: ${manifestFile}`));
         process.exit(1);
       }
-      const manifestContent = fs.readFileSync(manifestPath, "utf8");
+      const manifestContent = fs3.readFileSync(manifestPath, "utf8");
       const manifest = JSON.parse(manifestContent);
       spinner2.text = "Submitting application manifest...";
       const result = await client.submitAppManifest(manifest);
       spinner2.succeed("Application submitted successfully");
-      console.log(chalk.green(`
+      console.log(chalk5.green(`
 \u2705 ${result.message}`));
       if (manifest.app?.name) {
-        console.log(chalk.blue(`
+        console.log(chalk5.blue(`
 \u{1F4F1} App: ${manifest.app.name}`));
         console.log(
-          chalk.blue(`\u{1F464} Developer: ${manifest.app.developer_pubkey}`)
+          chalk5.blue(`\u{1F464} Developer: ${manifest.app.developer_pubkey}`)
         );
-        console.log(chalk.blue(`\u{1F4E6} Version: ${manifest.version?.semver}`));
+        console.log(chalk5.blue(`\u{1F4E6} Version: ${manifest.version?.semver}`));
       }
     } catch (error) {
       spinner2.fail("Failed to submit application");
       if (error instanceof Error) {
-        console.error(chalk.red(`Error: ${error.message}`));
+        console.error(chalk5.red(`Error: ${error.message}`));
       }
       process.exit(1);
     }
@@ -145,33 +793,33 @@ var developersCommand = new Command("developers").description("Manage developer
       baseURL: globalOpts?.url || "http://localhost:8082",
       timeout: parseInt(globalOpts?.timeout || "10000")
     });
-    const spinner2 = ora("Fetching developer profile...").start();
+    const spinner2 = ora6("Fetching developer profile...").start();
     try {
       const profile = await client.getDeveloper(pubkey);
       spinner2.succeed("Developer profile fetched successfully");
-      console.log(chalk.blue("\nDeveloper Profile:"));
-      console.log(chalk.green("Display Name:"), profile.display_name);
+      console.log(chalk5.blue("\nDeveloper Profile:"));
+      console.log(chalk5.green("Display Name:"), profile.display_name);
       if (profile.website) {
-        console.log(chalk.green("Website:"), profile.website);
+        console.log(chalk5.green("Website:"), profile.website);
       }
       if (profile.proofs.length > 0) {
-        console.log(chalk.green("\nProofs:"));
+        console.log(chalk5.green("\nProofs:"));
         const tableData = [
           ["Type", "Value", "Verified"],
           ...profile.proofs.map((proof) => [
             proof.type,
             proof.value.substring(0, 20) + "...",
-            proof.verified ? chalk.green("Yes") : chalk.red("No")
+            proof.verified ? chalk5.green("Yes") : chalk5.red("No")
           ])
         ];
         console.log(table(tableData));
       } else {
-        console.log(chalk.yellow("\nNo proofs found"));
+        console.log(chalk5.yellow("\nNo proofs found"));
       }
     } catch (error) {
       spinner2.fail("Failed to fetch developer profile");
       if (error instanceof Error) {
-        console.error(chalk.red(`Error: ${error.message}`));
+        console.error(chalk5.red(`Error: ${error.message}`));
       }
       process.exit(1);
     }
@@ -183,7 +831,7 @@ var developersCommand = new Command("developers").description("Manage developer
       baseURL: globalOpts?.url || "http://localhost:8082",
       timeout: parseInt(globalOpts?.timeout || "10000")
     });
-    const spinner2 = ora("Creating developer profile...").start();
+    const spinner2 = ora6("Creating developer profile...").start();
     try {
       let proofs = [];
       if (options.proofs) {
@@ -191,7 +839,7 @@ var developersCommand = new Command("developers").description("Manage developer
           proofs = JSON.parse(options.proofs);
         } catch {
           spinner2.fail("Invalid proofs JSON format");
-          console.error(chalk.red("Proofs must be a valid JSON array"));
+          console.error(chalk5.red("Proofs must be a valid JSON array"));
           process.exit(1);
         }
       }
@@ -203,18 +851,18 @@ var developersCommand = new Command("developers").description("Manage developer
       };
       const result = await client.submitDeveloperProfile(pubkey, profile);
       spinner2.succeed("Developer profile created successfully");
-      console.log(chalk.green(`
+      console.log(chalk5.green(`
 \u2705 ${result.message}`));
-      console.log(chalk.blue(`
+      console.log(chalk5.blue(`
 \u{1F464} Developer: ${displayName}`));
-      console.log(chalk.blue(`\u{1F511} Public Key: ${pubkey}`));
+      console.log(chalk5.blue(`\u{1F511} Public Key: ${pubkey}`));
       if (options.website) {
-        console.log(chalk.blue(`\u{1F310} Website: ${options.website}`));
+        console.log(chalk5.blue(`\u{1F310} Website: ${options.website}`));
       }
     } catch (error) {
       spinner2.fail("Failed to create developer profile");
       if (error instanceof Error) {
-        console.error(chalk.red(`Error: ${error.message}`));
+        console.error(chalk5.red(`Error: ${error.message}`));
       }
       process.exit(1);
     }
@@ -227,7 +875,7 @@ var attestationsCommand = new Command("attestations").description("Manage applic
       baseURL: globalOpts?.url || "http://localhost:8082",
       timeout: parseInt(globalOpts?.timeout || "10000")
     });
-    const spinner2 = ora(
+    const spinner2 = ora6(
       `Fetching attestation for ${name}@${version}...`
     ).start();
     try {
@@ -237,16 +885,16 @@ var attestationsCommand = new Command("attestations").description("Manage applic
         version
       );
       spinner2.succeed("Attestation fetched successfully");
-      console.log(chalk.blue("\nAttestation:"));
-      console.log(chalk.green("Status:"), attestation.status);
-      console.log(chalk.green("Timestamp:"), attestation.timestamp);
+      console.log(chalk5.blue("\nAttestation:"));
+      console.log(chalk5.green("Status:"), attestation.status);
+      console.log(chalk5.green("Timestamp:"), attestation.timestamp);
       if (attestation.comment) {
-        console.log(chalk.green("Comment:"), attestation.comment);
+        console.log(chalk5.green("Comment:"), attestation.comment);
       }
     } catch (error) {
       spinner2.fail("Failed to fetch attestation");
       if (error instanceof Error) {
-        console.error(chalk.red(`Error: ${error.message}`));
+        console.error(chalk5.red(`Error: ${error.message}`));
       }
       process.exit(1);
     }
@@ -254,19 +902,21 @@ var attestationsCommand = new Command("attestations").description("Manage applic
 );
 var healthCommand = new Command("health").description("Check the health of the SSApp Registry API").action(async (options, command) => {
   const globalOpts = command.parent?.opts();
-  const client = new SSAppRegistryClient({
-    baseURL: globalOpts?.url || "http://localhost:8082",
-    timeout: parseInt(globalOpts?.timeout || "10000")
-  });
-  const spinner2 = ora("Checking API health...").start();
+  const useLocal = globalOpts?.local || false;
+  const client = createRegistryClient(
+    useLocal,
+    globalOpts?.url,
+    parseInt(globalOpts?.timeout || "10000")
+  );
+  const spinner2 = ora6("Checking API health...").start();
   try {
     const health = await client.healthCheck();
     spinner2.succeed("API is healthy");
-    console.log(chalk.green(`Status: ${health.status}`));
+    console.log(chalk5.green(`Status: ${health.status}`));
   } catch (error) {
     spinner2.fail("API health check failed");
     if (error instanceof Error) {
-      console.error(chalk.red(`Error: ${error.message}`));
+      console.error(chalk5.red(`Error: ${error.message}`));
     }
     process.exit(1);
   }
@@ -301,7 +951,7 @@ This is a demo file that would normally contain the actual application data.`;
     );
   }
 }
-var spinner = (text) => ora(text);
+var spinner = (text) => ora6(text);
 
 // src/commands/ipfs.ts
 var ipfsCommand = new Command("ipfs").description("IPFS operations").addCommand(
@@ -339,6 +989,785 @@ var ipfsCommand = new Command("ipfs").description("IPFS operations").addCommand(
     }
   })
 );
+var LocalRegistryServer = class {
+  constructor(config) {
+    this.server = null;
+    this.isRunning = false;
+    this.config = config;
+    this.dataStore = new LocalDataStore(config);
+    this.artifactServer = new LocalArtifactServer(config, this.dataStore);
+  }
+  async start(port) {
+    if (this.isRunning) {
+      throw new Error("Local registry is already running");
+    }
+    const serverPort = port || this.config.getPort();
+    const host = this.config.getHost();
+    this.config.ensureDirectories();
+    this.server = fastify({
+      logger: {
+        level: "info"
+      }
+    });
+    await this.server.register(cors, {
+      origin: true,
+      credentials: true
+    });
+    await this.registerRoutes();
+    await this.server.listen({ port: serverPort, host });
+    this.isRunning = true;
+    console.log(
+      `Local registry server started on http://${host}:${serverPort}`
+    );
+  }
+  async stop() {
+    if (!this.server || !this.isRunning) {
+      throw new Error("Local registry is not running");
+    }
+    await this.server.close();
+    this.isRunning = false;
+    this.server = null;
+  }
+  async getStatus() {
+    const stats = this.dataStore.getStats();
+    const artifactStats = this.artifactServer.getArtifactStats();
+    return {
+      running: this.isRunning,
+      url: `http://${this.config.getHost()}:${this.config.getPort()}`,
+      dataDir: this.config.getDataDir(),
+      appsCount: stats.publishedApps,
+      artifactsCount: artifactStats.totalFiles
+    };
+  }
+  async reset() {
+    this.dataStore.reset();
+    const artifactsDir = this.config.getArtifactsDir();
+    if (fs3.existsSync(artifactsDir)) {
+      fs3.rmSync(artifactsDir, { recursive: true, force: true });
+    }
+  }
+  async backup(outputPath) {
+    return await this.dataStore.backup(outputPath);
+  }
+  async restore(backupPath) {
+    await this.dataStore.restore(backupPath);
+  }
+  async seed() {
+    await this.dataStore.seed();
+  }
+  async registerRoutes() {
+    if (!this.server) {
+      throw new Error("Server not initialized");
+    }
+    this.server.get("/healthz", async () => {
+      return { status: "ok" };
+    });
+    this.server.get("/stats", async () => {
+      const stats = this.dataStore.getStats();
+      const artifactStats = this.artifactServer.getArtifactStats();
+      return {
+        publishedApps: stats.publishedApps,
+        totalVersions: stats.totalVersions,
+        totalArtifacts: artifactStats.totalFiles,
+        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) => {
+        const { appId, version, filename } = request.params;
+        try {
+          const artifactData = await this.artifactServer.serveArtifact(
+            appId,
+            version,
+            filename
+          );
+          reply.header("Content-Type", "application/octet-stream");
+          reply.header(
+            "Content-Disposition",
+            `attachment; filename="${filename}"`
+          );
+          return artifactData;
+        } catch {
+          return {
+            statusCode: 404,
+            error: "Not Found",
+            message: "Artifact not found"
+          };
+        }
+      }
+    );
+    this.server.get("/artifacts/:hash", async (request, reply) => {
+      const { hash } = request.params;
+      try {
+        const artifactData = await this.artifactServer.serveByHash(hash);
+        reply.header("Content-Type", "application/octet-stream");
+        return artifactData;
+      } catch {
+        return {
+          statusCode: 404,
+          error: "Not Found",
+          message: "Artifact not found"
+        };
+      }
+    });
+    this.server.get("/local/status", async () => {
+      return await this.getStatus();
+    });
+    this.server.post("/local/reset", async () => {
+      await this.reset();
+      return { message: "Local registry data reset successfully" };
+    });
+    this.server.get("/local/backup", async (request) => {
+      const query = request.query;
+      const backupPath = await this.backup(query.output);
+      return { backupPath };
+    });
+    this.server.post("/local/restore", async (request) => {
+      const { backupPath } = request.body;
+      await this.restore(backupPath);
+      return { message: "Data restored successfully" };
+    });
+    this.server.post("/local/seed", async () => {
+      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")
+        };
+      }
+      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 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"
+        });
+      }
+      return {
+        plan: [{ action: "install", id: root.id, version: root.version }],
+        satisfies: [],
+        missing: []
+      };
+    });
+  }
+  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);
+          }
+        }
+      }
+    }
+    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) => {
+    const spinner2 = ora6("Starting local registry...").start();
+    try {
+      const config = new LocalConfig();
+      const server = new LocalRegistryServer(config);
+      await server.start(parseInt(options.port));
+      spinner2.succeed(
+        `Local registry started on http://${options.host}:${options.port}`
+      );
+      console.log(chalk5.blue("\n\u{1F4F1} Local Registry Status:"));
+      console.log(
+        chalk5.green(`\u2705 Server: http://${options.host}:${options.port}`)
+      );
+      console.log(chalk5.green(`\u{1F4C1} Data: ${config.getDataDir()}`));
+      console.log(
+        chalk5.green(
+          `\u{1F4CB} Health: http://${options.host}:${options.port}/healthz`
+        )
+      );
+      console.log(
+        chalk5.green(`\u{1F4CA} Stats: http://${options.host}:${options.port}/stats`)
+      );
+      console.log(
+        chalk5.blue(
+          "\n\u{1F4A1} Use --local flag with other commands to use local registry"
+        )
+      );
+    } catch (error) {
+      spinner2.fail("Failed to start local registry");
+      if (error instanceof Error) {
+        console.error(chalk5.red(`Error: ${error.message}`));
+      }
+      process.exit(1);
+    }
+  })
+);
+localCommand.addCommand(
+  new Command("stop").description("Stop local registry server").action(async () => {
+    const spinner2 = ora6("Stopping local registry...").start();
+    try {
+      const config = new LocalConfig();
+      const server = new LocalRegistryServer(config);
+      await server.stop();
+      spinner2.succeed("Local registry stopped");
+    } catch (error) {
+      spinner2.fail("Failed to stop local registry");
+      if (error instanceof Error) {
+        console.error(chalk5.red(`Error: ${error.message}`));
+      }
+      process.exit(1);
+    }
+  })
+);
+localCommand.addCommand(
+  new Command("status").description("Check local registry status").action(async () => {
+    const spinner2 = ora6("Checking local registry status...").start();
+    try {
+      const config = new LocalConfig();
+      const server = new LocalRegistryServer(config);
+      const status = await server.getStatus();
+      if (status.running) {
+        spinner2.succeed("Local registry is running");
+        console.log(chalk5.green(`\u2705 Server: ${status.url}`));
+        console.log(chalk5.green(`\u{1F4C1} Data: ${status.dataDir}`));
+        console.log(chalk5.green(`\u{1F4CA} Apps: ${status.appsCount} applications`));
+        console.log(
+          chalk5.green(`\u{1F4E6} Artifacts: ${status.artifactsCount} artifacts`)
+        );
+      } else {
+        spinner2.warn("Local registry is not running");
+        console.log(
+          chalk5.yellow(
+            '\u{1F4A1} Run "calimero-registry local start" to start the local registry'
+          )
+        );
+      }
+    } catch (error) {
+      spinner2.fail("Failed to check local registry status");
+      if (error instanceof Error) {
+        console.error(chalk5.red(`Error: ${error.message}`));
+      }
+      process.exit(1);
+    }
+  })
+);
+localCommand.addCommand(
+  new Command("reset").description("Reset local registry data").option("-f, --force", "Force reset without confirmation").action(async (options) => {
+    if (!options.force) {
+      console.log(
+        chalk5.yellow("\u26A0\uFE0F  This will delete all local registry data!")
+      );
+      console.log(chalk5.yellow("   Use --force flag to confirm"));
+      return;
+    }
+    const spinner2 = ora6("Resetting local registry data...").start();
+    try {
+      const config = new LocalConfig();
+      const server = new LocalRegistryServer(config);
+      await server.reset();
+      spinner2.succeed("Local registry data reset");
+      console.log(chalk5.green("\u2705 All local data has been cleared"));
+    } catch (error) {
+      spinner2.fail("Failed to reset local registry data");
+      if (error instanceof Error) {
+        console.error(chalk5.red(`Error: ${error.message}`));
+      }
+      process.exit(1);
+    }
+  })
+);
+localCommand.addCommand(
+  new Command("backup").description("Backup local registry data").option("-o, --output <file>", "Output file path").action(async (options) => {
+    const spinner2 = ora6("Creating backup...").start();
+    try {
+      const config = new LocalConfig();
+      const server = new LocalRegistryServer(config);
+      const backupPath = await server.backup(options.output);
+      spinner2.succeed("Backup created successfully");
+      console.log(chalk5.green(`\u{1F4E6} Backup saved to: ${backupPath}`));
+    } catch (error) {
+      spinner2.fail("Failed to create backup");
+      if (error instanceof Error) {
+        console.error(chalk5.red(`Error: ${error.message}`));
+      }
+      process.exit(1);
+    }
+  })
+);
+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)) {
+        spinner2.fail("Backup file not found");
+        console.error(chalk5.red(`File not found: ${backupFile}`));
+        process.exit(1);
+      }
+      const config = new LocalConfig();
+      const server = new LocalRegistryServer(config);
+      await server.restore(backupFile);
+      spinner2.succeed("Data restored successfully");
+      console.log(chalk5.green(`\u2705 Restored from: ${backupFile}`));
+    } catch (error) {
+      spinner2.fail("Failed to restore from backup");
+      if (error instanceof Error) {
+        console.error(chalk5.red(`Error: ${error.message}`));
+      }
+      process.exit(1);
+    }
+  })
+);
+localCommand.addCommand(
+  new Command("seed").description("Seed local registry with sample data").action(async () => {
+    const spinner2 = ora6("Seeding local registry with sample data...").start();
+    try {
+      const config = new LocalConfig();
+      const server = new LocalRegistryServer(config);
+      await server.seed();
+      spinner2.succeed("Sample data seeded successfully");
+      console.log(
+        chalk5.green("\u2705 Local registry populated with sample applications")
+      );
+      console.log(
+        chalk5.blue(
+          '\u{1F4A1} Run "calimero-registry apps list --local" to see the sample apps'
+        )
+      );
+    } catch (error) {
+      spinner2.fail("Failed to seed sample data");
+      if (error instanceof Error) {
+        console.error(chalk5.red(`Error: ${error.message}`));
+      }
+      process.exit(1);
+    }
+  })
+);
+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);
+      }
+    }
+  );
+}
+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);
+        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"
+          );
+        }
+      } 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) => {
+      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}`);
+          }
+        );
+        if (result.satisfies?.length > 0) {
+          console.log(`\u2705 Satisfies: ${result.satisfies.join(", ")}`);
+        }
+        if (result.missing?.length > 0) {
+          console.log(`\u274C Missing: ${result.missing.join(", ")}`);
+        }
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        console.error("\u274C Failed to resolve dependencies:", errorMessage);
+        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) => {
+    try {
+      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);
+      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(", ")}`
+        );
+        process.exit(1);
+      }
+      if (manifest.artifact.type !== "wasm" || manifest.artifact.target !== "node") {
+        console.error("\u274C Invalid artifact type or target");
+        process.exit(1);
+      }
+      if (!manifest.artifact.digest.match(/^sha256:[0-9a-f]{64}$/)) {
+        console.error("\u274C Invalid artifact digest format");
+        process.exit(1);
+      }
+      if (!manifest.artifact.uri.match(/^(https:\/\/|ipfs:\/\/)/)) {
+        console.error("\u274C Invalid artifact URI format");
+        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);
+      process.exit(1);
+    }
+  });
+}
 
 // src/index.ts
 var program = new Command();
@@ -351,19 +1780,22 @@ program.option(
   "Request timeout in milliseconds",
   "10000"
 );
+program.option("--local", "Use local registry instead of remote API");
 program.addCommand(appsCommand);
 program.addCommand(developersCommand);
 program.addCommand(attestationsCommand);
 program.addCommand(healthCommand);
 program.addCommand(ipfsCommand);
+program.addCommand(localCommand);
+program.addCommand(v1Command);
 program.exitOverride();
 try {
   program.parse();
 } catch (err) {
   if (err instanceof Error) {
-    console.error(chalk.red("Error:"), err.message);
+    console.error(chalk5.red("Error:"), err.message);
   } else {
-    console.error(chalk.red("Unknown error occurred"));
+    console.error(chalk5.red("Unknown error occurred"));
   }
   process.exit(1);
 }