@calimero-network/registry-cli 1.6.0 → 1.6.1

package/dist/index.js

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