@calimero-network/registry-cli 1.1.0 → 1.3.0

package/dist/index.js

@@ -10,6 +10,8 @@ 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() {
@@ -227,7 +229,7 @@ var LocalDataStore = class {
   getAppVersions(appId) {
     const versions = [];
     for (const [key, manifest] of this.data.manifests.entries()) {
-      if (manifest.app.id === appId) {
+      if (key.startsWith(`${appId}/`)) {
         const semver = key.split("/").pop();
         versions.push({
           semver,
@@ -243,12 +245,8 @@ var LocalDataStore = class {
   }
   // Manifest management
   getManifest(appId, semver) {
-    for (const [, manifest] of this.data.manifests.entries()) {
-      if (manifest.app.id === appId && manifest.version.semver === semver) {
-        return manifest;
-      }
-    }
-    return void 0;
+    const manifestKey = `${appId}/${semver}`;
+    return this.data.manifests.get(manifestKey);
   }
   setManifest(manifestKey, manifest) {
     this.data.manifests.set(manifestKey, manifest);
@@ -370,7 +368,7 @@ var LocalDataStore = class {
       this.setApp(appKey, app);
     });
     sampleManifests.forEach((manifest) => {
-      const manifestKey = `${manifest.app.developer_pubkey}/${manifest.app.name}/${manifest.version.semver}`;
+      const manifestKey = `${manifest.app.app_id}/${manifest.version.semver}`;
       this.setManifest(manifestKey, manifest);
     });
     this.saveData();
@@ -458,7 +456,7 @@ var LocalArtifactServer = class {
             const filename = path.basename(artifact.path);
             updatedArtifact.mirrors = [
               this.getArtifactUrl(
-                manifest.app.id || manifest.app.name,
+                manifest.app.id || manifest.app.name?.replace(/\s+/g, "-").toLowerCase(),
                 manifest.version.semver,
                 filename
               )
@@ -582,9 +580,9 @@ var LocalRegistryClient = class {
       throw new Error("Invalid manifest structure");
     }
     const processedManifest = await this.processManifestArtifacts(manifest);
-    const manifestKey = `${manifest.app.developer_pubkey}/${manifest.app.name}/${manifest.version.semver}`;
+    const manifestKey = `${manifest.app.app_id}/${manifest.version.semver}`;
     this.dataStore.setManifest(manifestKey, processedManifest);
-    const appKey = `${manifest.app.developer_pubkey}/${manifest.app.name}`;
+    const appKey = manifest.app.app_id;
     const appSummary = {
       name: manifest.app.name,
       developer_pubkey: manifest.app.developer_pubkey,
@@ -612,7 +610,7 @@ var LocalRegistryClient = class {
           const processedArtifact = { ...artifact };
           if (artifact.path && fs3.existsSync(artifact.path)) {
             const filename = path.basename(artifact.path);
-            const appId = manifest.app.id || manifest.app.name;
+            const appId = manifest.app.id || manifest.app.name?.replace(/\s+/g, "-").toLowerCase();
             try {
               await this.artifactServer.copyArtifactToLocal(
                 artifact.path,
@@ -1076,35 +1074,65 @@ var LocalRegistryServer = class {
     });
     this.server.get("/apps", async (request) => {
       const query = request.query;
+      if (query.id && query.versions === "true") {
+        return {
+          id: query.id,
+          versions: this.dataStore.getAppVersions(query.id)
+        };
+      }
+      if (query.id && query.version) {
+        const manifest = this.dataStore.getManifest(query.id, query.version);
+        if (!manifest) {
+          return {
+            statusCode: 404,
+            error: "Not Found",
+            message: "Manifest not found"
+          };
+        }
+        return this.artifactServer.updateManifestArtifacts(manifest);
+      }
       return this.dataStore.getApps(query);
     });
     this.server.get("/apps/:appId", async (request) => {
       const { appId } = request.params;
-      return this.dataStore.getAppVersions(appId);
+      const versions = this.dataStore.getAppVersions(appId);
+      return {
+        id: appId,
+        versions
+      };
     });
     this.server.get("/apps/:appId/:semver", async (request) => {
       const { appId, semver } = request.params;
       const manifest = this.dataStore.getManifest(appId, semver);
       if (!manifest) {
-        throw this.server.httpErrors.notFound("Manifest not found");
+        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)) {
-        throw this.server.httpErrors.badRequest("Invalid manifest structure");
+        return {
+          statusCode: 400,
+          error: "Bad Request",
+          message: "Invalid manifest structure"
+        };
       }
       const processedManifest = await this.processManifestArtifacts(manifest);
-      const manifestKey = `${manifest.app.developer_pubkey}/${manifest.app.name}/${manifest.version.semver}`;
+      const manifestKey = `${manifest.app.app_id}/${manifest.version.semver}`;
       this.dataStore.setManifest(manifestKey, processedManifest);
-      const appKey = `${manifest.app.developer_pubkey}/${manifest.app.name}`;
+      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
+        alias: manifest.app.name
+        // Use name as alias
       };
       this.dataStore.setApp(appKey, appSummary);
       return {
@@ -1130,7 +1158,11 @@ var LocalRegistryServer = class {
           );
           return artifactData;
         } catch {
-          throw this.server.httpErrors.notFound("Artifact not found");
+          return {
+            statusCode: 404,
+            error: "Not Found",
+            message: "Artifact not found"
+          };
         }
       }
     );
@@ -1141,7 +1173,11 @@ var LocalRegistryServer = class {
         reply.header("Content-Type", "application/octet-stream");
         return artifactData;
       } catch {
-        throw this.server.httpErrors.notFound("Artifact not found");
+        return {
+          statusCode: 404,
+          error: "Not Found",
+          message: "Artifact not found"
+        };
       }
     });
     this.server.get("/local/status", async () => {
@@ -1165,41 +1201,151 @@ 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")
+        };
+      }
+      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.name && manifest.app.developer_pubkey && manifest.version && manifest.version.semver && manifest.artifacts && manifest.artifacts.length > 0);
+    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 (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;
-            try {
-              await this.artifactServer.copyArtifactToLocal(
-                artifact.path,
+    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.semver,
+                manifest.version,
                 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);
-            }
+              )
+            };
+          } catch (error) {
+            console.warn(`Failed to copy artifact ${filePath}:`, error);
           }
-          return processedArtifact;
-        })
-      );
+        }
+      }
     }
     return processedManifest;
   }
@@ -1384,6 +1530,265 @@ 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);
+      }
+    }
+  );
+}
+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();
@@ -1403,6 +1808,7 @@ program.addCommand(attestationsCommand);
 program.addCommand(healthCommand);
 program.addCommand(ipfsCommand);
 program.addCommand(localCommand);
+program.addCommand(v1Command);
 program.exitOverride();
 try {
   program.parse();