@devkong/cli 0.0.39 → 0.0.41

package/assets/python-install.bat

@@ -23,4 +23,6 @@ cd %EXTENSION_DIR%
 
 call .venv\Scripts\activate.bat
 
-%PIP_CMD% install -r requirements.txt -r requirements-dev.txt
+%PIP_CMD% freeze > requirements-lock.txt
+%PIP_CMD% install --default-timeout=120 -r requirements.txt -r requirements-dev.txt
+%PIP_CMD% freeze > requirements-lock.txt

package/assets/python-install.sh

@@ -20,4 +20,6 @@ $PYTHON_CMD -m venv .venv
 
 source .venv/bin/activate
 
-$PIP_CMD install -r requirements-dev.txt -r requirements.txt
+$PIP_CMD freeze > requirements-lock.txt
+$PIP_CMD install --default-timeout=120 -r requirements-dev.txt -r requirements.txt
+$PIP_CMD freeze > requirements-lock.txt

package/index.js

@@ -3928,256 +3928,504 @@ var require_main2 = __commonJS({
   }
 });
 
-// packages/kong-cli/node_modules/@napi-rs/keyring/index.js
+// node_modules/@napi-rs/keyring/index.js
 var require_keyring = __commonJS({
-  "packages/kong-cli/node_modules/@napi-rs/keyring/index.js"(exports2, module2) {
-    var { existsSync, readFileSync: readFileSync2 } = require("fs");
-    var { join } = require("path");
-    var { platform: platform3, arch } = process;
+  "node_modules/@napi-rs/keyring/index.js"(exports2, module2) {
+    var { createRequire } = require("node:module");
+    require = createRequire(__filename);
+    var { readFileSync: readFileSync2 } = require("node:fs");
     var nativeBinding = null;
-    var localFileExisted = false;
-    var loadError = null;
-    function isMusl() {
-      if (!process.report || typeof process.report.getReport !== "function") {
-        try {
-          const lddPath = require("child_process").execSync("which ldd").toString().trim();
-          return readFileSync2(lddPath, "utf8").includes("musl");
-        } catch (e) {
+    var loadErrors = [];
+    var isMusl = () => {
+      let musl = false;
+      if (process.platform === "linux") {
+        musl = isMuslFromFilesystem();
+        if (musl === null) {
+          musl = isMuslFromReport();
+        }
+        if (musl === null) {
+          musl = isMuslFromChildProcess();
+        }
+      }
+      return musl;
+    };
+    var isFileMusl = (f) => f.includes("libc.musl-") || f.includes("ld-musl-");
+    var isMuslFromFilesystem = () => {
+      try {
+        return readFileSync2("/usr/bin/ldd", "utf-8").includes("musl");
+      } catch {
+        return null;
+      }
+    };
+    var isMuslFromReport = () => {
+      let report = null;
+      if (typeof process.report?.getReport === "function") {
+        process.report.excludeNetwork = true;
+        report = process.report.getReport();
+      }
+      if (!report) {
+        return null;
+      }
+      if (report.header && report.header.glibcVersionRuntime) {
+        return false;
+      }
+      if (Array.isArray(report.sharedObjects)) {
+        if (report.sharedObjects.some(isFileMusl)) {
           return true;
         }
-      } else {
-        const { glibcVersionRuntime } = process.report.getReport().header;
-        return !glibcVersionRuntime;
       }
-    }
-    switch (platform3) {
-      case "android":
-        switch (arch) {
-          case "arm64":
-            localFileExisted = existsSync(join(__dirname, "keyring.android-arm64.node"));
+      return false;
+    };
+    var isMuslFromChildProcess = () => {
+      try {
+        return require("child_process").execSync("ldd --version", { encoding: "utf8" }).includes("musl");
+      } catch (e) {
+        return false;
+      }
+    };
+    function requireNative() {
+      if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) {
+        try {
+          nativeBinding = require(process.env.NAPI_RS_NATIVE_LIBRARY_PATH);
+        } catch (err) {
+          loadErrors.push(err);
+        }
+      } else if (process.platform === "android") {
+        if (process.arch === "arm64") {
+          try {
+            return require("./keyring.android-arm64.node");
+          } catch (e) {
+            loadErrors.push(e);
+          }
+          try {
+            const binding = require("@napi-rs/keyring-android-arm64");
+            const bindingPackageVersion = require("@napi-rs/keyring-android-arm64/package.json").version;
+            if (bindingPackageVersion !== "1.2.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+              throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+            }
+            return binding;
+          } catch (e) {
+            loadErrors.push(e);
+          }
+        } else if (process.arch === "arm") {
+          try {
+            return require("./keyring.android-arm-eabi.node");
+          } catch (e) {
+            loadErrors.push(e);
+          }
+          try {
+            const binding = require("@napi-rs/keyring-android-arm-eabi");
+            const bindingPackageVersion = require("@napi-rs/keyring-android-arm-eabi/package.json").version;
+            if (bindingPackageVersion !== "1.2.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+              throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+            }
+            return binding;
+          } catch (e) {
+            loadErrors.push(e);
+          }
+        } else {
+          loadErrors.push(new Error(`Unsupported architecture on Android ${process.arch}`));
+        }
+      } else if (process.platform === "win32") {
+        if (process.arch === "x64") {
+          try {
+            return require("./keyring.win32-x64-msvc.node");
+          } catch (e) {
+            loadErrors.push(e);
+          }
+          try {
+            const binding = require("@napi-rs/keyring-win32-x64-msvc");
+            const bindingPackageVersion = require("@napi-rs/keyring-win32-x64-msvc/package.json").version;
+            if (bindingPackageVersion !== "1.2.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+              throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+            }
+            return binding;
+          } catch (e) {
+            loadErrors.push(e);
+          }
+        } else if (process.arch === "ia32") {
+          try {
+            return require("./keyring.win32-ia32-msvc.node");
+          } catch (e) {
+            loadErrors.push(e);
+          }
+          try {
+            const binding = require("@napi-rs/keyring-win32-ia32-msvc");
+            const bindingPackageVersion = require("@napi-rs/keyring-win32-ia32-msvc/package.json").version;
+            if (bindingPackageVersion !== "1.2.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+              throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+            }
+            return binding;
+          } catch (e) {
+            loadErrors.push(e);
+          }
+        } else if (process.arch === "arm64") {
+          try {
+            return require("./keyring.win32-arm64-msvc.node");
+          } catch (e) {
+            loadErrors.push(e);
+          }
+          try {
+            const binding = require("@napi-rs/keyring-win32-arm64-msvc");
+            const bindingPackageVersion = require("@napi-rs/keyring-win32-arm64-msvc/package.json").version;
+            if (bindingPackageVersion !== "1.2.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+              throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+            }
+            return binding;
+          } catch (e) {
+            loadErrors.push(e);
+          }
+        } else {
+          loadErrors.push(new Error(`Unsupported architecture on Windows: ${process.arch}`));
+        }
+      } else if (process.platform === "darwin") {
+        try {
+          return require("./keyring.darwin-universal.node");
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          const binding = require("@napi-rs/keyring-darwin-universal");
+          const bindingPackageVersion = require("@napi-rs/keyring-darwin-universal/package.json").version;
+          if (bindingPackageVersion !== "1.2.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+            throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+          }
+          return binding;
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        if (process.arch === "x64") {
+          try {
+            return require("./keyring.darwin-x64.node");
+          } catch (e) {
+            loadErrors.push(e);
+          }
+          try {
+            const binding = require("@napi-rs/keyring-darwin-x64");
+            const bindingPackageVersion = require("@napi-rs/keyring-darwin-x64/package.json").version;
+            if (bindingPackageVersion !== "1.2.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+              throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+            }
+            return binding;
+          } catch (e) {
+            loadErrors.push(e);
+          }
+        } else if (process.arch === "arm64") {
+          try {
+            return require("./keyring.darwin-arm64.node");
+          } catch (e) {
+            loadErrors.push(e);
+          }
+          try {
+            const binding = require("@napi-rs/keyring-darwin-arm64");
+            const bindingPackageVersion = require("@napi-rs/keyring-darwin-arm64/package.json").version;
+            if (bindingPackageVersion !== "1.2.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+              throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+            }
+            return binding;
+          } catch (e) {
+            loadErrors.push(e);
+          }
+        } else {
+          loadErrors.push(new Error(`Unsupported architecture on macOS: ${process.arch}`));
+        }
+      } else if (process.platform === "freebsd") {
+        if (process.arch === "x64") {
+          try {
+            return require("./keyring.freebsd-x64.node");
+          } catch (e) {
+            loadErrors.push(e);
+          }
+          try {
+            const binding = require("@napi-rs/keyring-freebsd-x64");
+            const bindingPackageVersion = require("@napi-rs/keyring-freebsd-x64/package.json").version;
+            if (bindingPackageVersion !== "1.2.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+              throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+            }
+            return binding;
+          } catch (e) {
+            loadErrors.push(e);
+          }
+        } else if (process.arch === "arm64") {
+          try {
+            return require("./keyring.freebsd-arm64.node");
+          } catch (e) {
+            loadErrors.push(e);
+          }
+          try {
+            const binding = require("@napi-rs/keyring-freebsd-arm64");
+            const bindingPackageVersion = require("@napi-rs/keyring-freebsd-arm64/package.json").version;
+            if (bindingPackageVersion !== "1.2.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+              throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+            }
+            return binding;
+          } catch (e) {
+            loadErrors.push(e);
+          }
+        } else {
+          loadErrors.push(new Error(`Unsupported architecture on FreeBSD: ${process.arch}`));
+        }
+      } else if (process.platform === "linux") {
+        if (process.arch === "x64") {
+          if (isMusl()) {
             try {
-              if (localFileExisted) {
-                nativeBinding = require("./keyring.android-arm64.node");
-              } else {
-                nativeBinding = require("@napi-rs/keyring-android-arm64");
-              }
+              return require("./keyring.linux-x64-musl.node");
             } catch (e) {
-              loadError = e;
+              loadErrors.push(e);
             }
-            break;
-          case "arm":
-            localFileExisted = existsSync(join(__dirname, "keyring.android-arm-eabi.node"));
             try {
-              if (localFileExisted) {
-                nativeBinding = require("./keyring.android-arm-eabi.node");
-              } else {
-                nativeBinding = require("@napi-rs/keyring-android-arm-eabi");
+              const binding = require("@napi-rs/keyring-linux-x64-musl");
+              const bindingPackageVersion = require("@napi-rs/keyring-linux-x64-musl/package.json").version;
+              if (bindingPackageVersion !== "1.2.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+                throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
               }
+              return binding;
             } catch (e) {
-              loadError = e;
+              loadErrors.push(e);
             }
-            break;
-          default:
-            throw new Error(`Unsupported architecture on Android ${arch}`);
-        }
-        break;
-      case "win32":
-        switch (arch) {
-          case "x64":
-            localFileExisted = existsSync(
-              join(__dirname, "keyring.win32-x64-msvc.node")
-            );
+          } else {
             try {
-              if (localFileExisted) {
-                nativeBinding = require("./keyring.win32-x64-msvc.node");
-              } else {
-                nativeBinding = require("@napi-rs/keyring-win32-x64-msvc");
-              }
+              return require("./keyring.linux-x64-gnu.node");
             } catch (e) {
-              loadError = e;
+              loadErrors.push(e);
             }
-            break;
-          case "ia32":
-            localFileExisted = existsSync(
-              join(__dirname, "keyring.win32-ia32-msvc.node")
-            );
             try {
-              if (localFileExisted) {
-                nativeBinding = require("./keyring.win32-ia32-msvc.node");
-              } else {
-                nativeBinding = require("@napi-rs/keyring-win32-ia32-msvc");
+              const binding = require("@napi-rs/keyring-linux-x64-gnu");
+              const bindingPackageVersion = require("@napi-rs/keyring-linux-x64-gnu/package.json").version;
+              if (bindingPackageVersion !== "1.2.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+                throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
               }
+              return binding;
             } catch (e) {
-              loadError = e;
+              loadErrors.push(e);
             }
-            break;
-          case "arm64":
-            localFileExisted = existsSync(
-              join(__dirname, "keyring.win32-arm64-msvc.node")
-            );
+          }
+        } else if (process.arch === "arm64") {
+          if (isMusl()) {
             try {
-              if (localFileExisted) {
-                nativeBinding = require("./keyring.win32-arm64-msvc.node");
-              } else {
-                nativeBinding = require("@napi-rs/keyring-win32-arm64-msvc");
+              return require("./keyring.linux-arm64-musl.node");
+            } catch (e) {
+              loadErrors.push(e);
+            }
+            try {
+              const binding = require("@napi-rs/keyring-linux-arm64-musl");
+              const bindingPackageVersion = require("@napi-rs/keyring-linux-arm64-musl/package.json").version;
+              if (bindingPackageVersion !== "1.2.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+                throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
               }
+              return binding;
             } catch (e) {
-              loadError = e;
+              loadErrors.push(e);
             }
-            break;
-          default:
-            throw new Error(`Unsupported architecture on Windows: ${arch}`);
-        }
-        break;
-      case "darwin":
-        localFileExisted = existsSync(join(__dirname, "keyring.darwin-universal.node"));
-        try {
-          if (localFileExisted) {
-            nativeBinding = require("./keyring.darwin-universal.node");
           } else {
-            nativeBinding = require("@napi-rs/keyring-darwin-universal");
-          }
-          break;
-        } catch {
-        }
-        switch (arch) {
-          case "x64":
-            localFileExisted = existsSync(join(__dirname, "keyring.darwin-x64.node"));
             try {
-              if (localFileExisted) {
-                nativeBinding = require("./keyring.darwin-x64.node");
-              } else {
-                nativeBinding = require("@napi-rs/keyring-darwin-x64");
-              }
+              return require("./keyring.linux-arm64-gnu.node");
             } catch (e) {
-              loadError = e;
+              loadErrors.push(e);
             }
-            break;
-          case "arm64":
-            localFileExisted = existsSync(
-              join(__dirname, "keyring.darwin-arm64.node")
-            );
             try {
-              if (localFileExisted) {
-                nativeBinding = require("./keyring.darwin-arm64.node");
-              } else {
-                nativeBinding = require("@napi-rs/keyring-darwin-arm64");
+              const binding = require("@napi-rs/keyring-linux-arm64-gnu");
+              const bindingPackageVersion = require("@napi-rs/keyring-linux-arm64-gnu/package.json").version;
+              if (bindingPackageVersion !== "1.2.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+                throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
               }
+              return binding;
             } catch (e) {
-              loadError = e;
+              loadErrors.push(e);
             }
-            break;
-          default:
-            throw new Error(`Unsupported architecture on macOS: ${arch}`);
-        }
-        break;
-      case "freebsd":
-        if (arch !== "x64") {
-          throw new Error(`Unsupported architecture on FreeBSD: ${arch}`);
-        }
-        localFileExisted = existsSync(join(__dirname, "keyring.freebsd-x64.node"));
-        try {
-          if (localFileExisted) {
-            nativeBinding = require("./keyring.freebsd-x64.node");
-          } else {
-            nativeBinding = require("@napi-rs/keyring-freebsd-x64");
           }
-        } catch (e) {
-          loadError = e;
-        }
-        break;
-      case "linux":
-        switch (arch) {
-          case "x64":
-            if (isMusl()) {
-              localFileExisted = existsSync(
-                join(__dirname, "keyring.linux-x64-musl.node")
-              );
-              try {
-                if (localFileExisted) {
-                  nativeBinding = require("./keyring.linux-x64-musl.node");
-                } else {
-                  nativeBinding = require("@napi-rs/keyring-linux-x64-musl");
-                }
-              } catch (e) {
-                loadError = e;
-              }
-            } else {
-              localFileExisted = existsSync(
-                join(__dirname, "keyring.linux-x64-gnu.node")
-              );
-              try {
-                if (localFileExisted) {
-                  nativeBinding = require("./keyring.linux-x64-gnu.node");
-                } else {
-                  nativeBinding = require("@napi-rs/keyring-linux-x64-gnu");
-                }
-              } catch (e) {
-                loadError = e;
+        } else if (process.arch === "arm") {
+          if (isMusl()) {
+            try {
+              return require("./keyring.linux-arm-musleabihf.node");
+            } catch (e) {
+              loadErrors.push(e);
+            }
+            try {
+              const binding = require("@napi-rs/keyring-linux-arm-musleabihf");
+              const bindingPackageVersion = require("@napi-rs/keyring-linux-arm-musleabihf/package.json").version;
+              if (bindingPackageVersion !== "1.2.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+                throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
               }
+              return binding;
+            } catch (e) {
+              loadErrors.push(e);
             }
-            break;
-          case "arm64":
-            if (isMusl()) {
-              localFileExisted = existsSync(
-                join(__dirname, "keyring.linux-arm64-musl.node")
-              );
-              try {
-                if (localFileExisted) {
-                  nativeBinding = require("./keyring.linux-arm64-musl.node");
-                } else {
-                  nativeBinding = require("@napi-rs/keyring-linux-arm64-musl");
-                }
-              } catch (e) {
-                loadError = e;
+          } else {
+            try {
+              return require("./keyring.linux-arm-gnueabihf.node");
+            } catch (e) {
+              loadErrors.push(e);
+            }
+            try {
+              const binding = require("@napi-rs/keyring-linux-arm-gnueabihf");
+              const bindingPackageVersion = require("@napi-rs/keyring-linux-arm-gnueabihf/package.json").version;
+              if (bindingPackageVersion !== "1.2.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+                throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
               }
-            } else {
-              localFileExisted = existsSync(
-                join(__dirname, "keyring.linux-arm64-gnu.node")
-              );
-              try {
-                if (localFileExisted) {
-                  nativeBinding = require("./keyring.linux-arm64-gnu.node");
-                } else {
-                  nativeBinding = require("@napi-rs/keyring-linux-arm64-gnu");
-                }
-              } catch (e) {
-                loadError = e;
+              return binding;
+            } catch (e) {
+              loadErrors.push(e);
+            }
+          }
+        } else if (process.arch === "riscv64") {
+          if (isMusl()) {
+            try {
+              return require("./keyring.linux-riscv64-musl.node");
+            } catch (e) {
+              loadErrors.push(e);
+            }
+            try {
+              const binding = require("@napi-rs/keyring-linux-riscv64-musl");
+              const bindingPackageVersion = require("@napi-rs/keyring-linux-riscv64-musl/package.json").version;
+              if (bindingPackageVersion !== "1.2.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+                throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
               }
+              return binding;
+            } catch (e) {
+              loadErrors.push(e);
             }
-            break;
-          case "arm":
-            localFileExisted = existsSync(
-              join(__dirname, "keyring.linux-arm-gnueabihf.node")
-            );
+          } else {
             try {
-              if (localFileExisted) {
-                nativeBinding = require("./keyring.linux-arm-gnueabihf.node");
-              } else {
-                nativeBinding = require("@napi-rs/keyring-linux-arm-gnueabihf");
+              return require("./keyring.linux-riscv64-gnu.node");
+            } catch (e) {
+              loadErrors.push(e);
+            }
+            try {
+              const binding = require("@napi-rs/keyring-linux-riscv64-gnu");
+              const bindingPackageVersion = require("@napi-rs/keyring-linux-riscv64-gnu/package.json").version;
+              if (bindingPackageVersion !== "1.2.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+                throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
               }
+              return binding;
             } catch (e) {
-              loadError = e;
+              loadErrors.push(e);
             }
-            break;
-          default:
-            throw new Error(`Unsupported architecture on Linux: ${arch}`);
+          }
+        } else if (process.arch === "ppc64") {
+          try {
+            return require("./keyring.linux-ppc64-gnu.node");
+          } catch (e) {
+            loadErrors.push(e);
+          }
+          try {
+            const binding = require("@napi-rs/keyring-linux-ppc64-gnu");
+            const bindingPackageVersion = require("@napi-rs/keyring-linux-ppc64-gnu/package.json").version;
+            if (bindingPackageVersion !== "1.2.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+              throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+            }
+            return binding;
+          } catch (e) {
+            loadErrors.push(e);
+          }
+        } else if (process.arch === "s390x") {
+          try {
+            return require("./keyring.linux-s390x-gnu.node");
+          } catch (e) {
+            loadErrors.push(e);
+          }
+          try {
+            const binding = require("@napi-rs/keyring-linux-s390x-gnu");
+            const bindingPackageVersion = require("@napi-rs/keyring-linux-s390x-gnu/package.json").version;
+            if (bindingPackageVersion !== "1.2.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+              throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+            }
+            return binding;
+          } catch (e) {
+            loadErrors.push(e);
+          }
+        } else {
+          loadErrors.push(new Error(`Unsupported architecture on Linux: ${process.arch}`));
         }
-        break;
-      default:
-        throw new Error(`Unsupported OS: ${platform3}, architecture: ${arch}`);
+      } else if (process.platform === "openharmony") {
+        if (process.arch === "arm64") {
+          try {
+            return require("./keyring.openharmony-arm64.node");
+          } catch (e) {
+            loadErrors.push(e);
+          }
+          try {
+            const binding = require("@napi-rs/keyring-openharmony-arm64");
+            const bindingPackageVersion = require("@napi-rs/keyring-openharmony-arm64/package.json").version;
+            if (bindingPackageVersion !== "1.2.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+              throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+            }
+            return binding;
+          } catch (e) {
+            loadErrors.push(e);
+          }
+        } else if (process.arch === "x64") {
+          try {
+            return require("./keyring.openharmony-x64.node");
+          } catch (e) {
+            loadErrors.push(e);
+          }
+          try {
+            const binding = require("@napi-rs/keyring-openharmony-x64");
+            const bindingPackageVersion = require("@napi-rs/keyring-openharmony-x64/package.json").version;
+            if (bindingPackageVersion !== "1.2.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+              throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+            }
+            return binding;
+          } catch (e) {
+            loadErrors.push(e);
+          }
+        } else if (process.arch === "arm") {
+          try {
+            return require("./keyring.openharmony-arm.node");
+          } catch (e) {
+            loadErrors.push(e);
+          }
+          try {
+            const binding = require("@napi-rs/keyring-openharmony-arm");
+            const bindingPackageVersion = require("@napi-rs/keyring-openharmony-arm/package.json").version;
+            if (bindingPackageVersion !== "1.2.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") {
+              throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+            }
+            return binding;
+          } catch (e) {
+            loadErrors.push(e);
+          }
+        } else {
+          loadErrors.push(new Error(`Unsupported architecture on OpenHarmony: ${process.arch}`));
+        }
+      } else {
+        loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`));
+      }
+    }
+    nativeBinding = requireNative();
+    if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
+      try {
+        nativeBinding = require("./keyring.wasi.cjs");
+      } catch (err) {
+        if (process.env.NAPI_RS_FORCE_WASI) {
+          loadErrors.push(err);
+        }
+      }
+      if (!nativeBinding) {
+        try {
+          nativeBinding = require("@napi-rs/keyring-wasm32-wasi");
+        } catch (err) {
+          if (process.env.NAPI_RS_FORCE_WASI) {
+            loadErrors.push(err);
+          }
+        }
+      }
     }
     if (!nativeBinding) {
-      if (loadError) {
-        throw loadError;
+      if (loadErrors.length > 0) {
+        throw new Error(
+          `Cannot find native binding. npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). Please try \`npm i\` again after removing both package-lock.json and node_modules directory.`,
+          { cause: loadErrors }
+        );
       }
       throw new Error(`Failed to load native binding`);
     }
-    var { AsyncEntry, Entry: Entry3, findCredentials, findCredentialsAsync } = nativeBinding;
-    module2.exports.AsyncEntry = AsyncEntry;
-    module2.exports.Entry = Entry3;
-    module2.exports.findCredentials = findCredentials;
-    module2.exports.findCredentialsAsync = findCredentialsAsync;
+    module2.exports = nativeBinding;
+    module2.exports.AsyncEntry = nativeBinding.AsyncEntry;
+    module2.exports.Entry = nativeBinding.Entry;
+    module2.exports.findCredentials = nativeBinding.findCredentials;
+    module2.exports.findCredentialsAsync = nativeBinding.findCredentialsAsync;
   }
 });
 
@@ -58633,28 +58881,6 @@ var require__ = __commonJS({
   }
 });
 
-// node_modules/commander/esm.mjs
-var import_index = __toESM(require_commander(), 1);
-var {
-  program,
-  createCommand,
-  createArgument,
-  createOption,
-  CommanderError,
-  InvalidArgumentError,
-  InvalidOptionArgumentError,
-  // deprecated old name
-  Command,
-  Argument,
-  Option,
-  Help
-} = import_index.default;
-
-// packages/kong-cli/src/index.ts
-var import_dotenv = __toESM(require_main());
-var import_dotenv_expand = __toESM(require_main2());
-var import_path5 = __toESM(require("path"));
-
 // packages/kong-ts/src/lib/text.ts
 function trimSlashes(text) {
   return text.replace(/^\/+|\/+$/g, "");
@@ -72302,6 +72528,28 @@ function joinUrlAndPath(baseUrl, ...pathSegments) {
   return urlText([trimmedBaseUrl, ...trimmedPathSegments].join("/"));
 }
 
+// node_modules/commander/esm.mjs
+var import_index = __toESM(require_commander(), 1);
+var {
+  program,
+  createCommand,
+  createArgument,
+  createOption,
+  CommanderError,
+  InvalidArgumentError,
+  InvalidOptionArgumentError,
+  // deprecated old name
+  Command,
+  Argument,
+  Option,
+  Help
+} = import_index.default;
+
+// packages/kong-cli/src/index.ts
+var import_dotenv = __toESM(require_main());
+var import_dotenv_expand = __toESM(require_main2());
+var import_path5 = __toESM(require("path"));
+
 // packages/kong-cli/src/commands/configureCommand.ts
 var import_keyring = __toESM(require_keyring());
 
@@ -81939,8 +82187,8 @@ var RegistryClient = class {
     this.headerProvider = headerProvider2;
     this.baseUrl = joinUrlAndPath(baseUrl, "/api/registry");
   }
-  async getPublishDetails(repoName) {
-    const url2 = joinUrlAndPath(this.baseUrl, "v1/repository", repoName, "publish/details");
+  async getPublishDetails(appName) {
+    const url2 = joinUrlAndPath(this.baseUrl, "v1/repository", appName, "publish/details");
     return (await axios_default.post(url2, {}, await this.headerProvider())).data;
   }
 };
@@ -81948,6 +82196,7 @@ var RegistryClient = class {
 // packages/kong-cli/src/commands/publishVersionCommand.ts
 var PublishVersionCommand = class {
   constructor(profile, verbose = false, contractPath = null) {
+    this.profile = profile;
     this.verbose = verbose;
     this.contractPath = contractPath;
     this.isWin = process.platform === "win32";
@@ -81964,8 +82213,8 @@ var PublishVersionCommand = class {
   get wslPrefix() {
     return this.isWin && !this.hasDocker ? "wsl" : "";
   }
-  async execute(repoName, notes) {
-    await new Listr([...this.flowFactory(repoName, notes)], {
+  async execute(appName, notes) {
+    await new Listr([...this.flowFactory(appName, notes)], {
       renderer: "default",
       rendererOptions: {
         logger: new ListrLogger({
@@ -81974,7 +82223,7 @@ var PublishVersionCommand = class {
       }
     }).run();
   }
-  *flowFactory(repoName, notes) {
+  *flowFactory(appName, notes) {
     const kongJson = getKongJson();
     if (kongJson.sdk === "kotlin" && !this.contractPath) {
       yield {
@@ -82005,15 +82254,16 @@ var PublishVersionCommand = class {
     yield {
       title: "Get publish details",
       task: async (ctx) => {
-        ctx.publishDetails = await this.registryClient.getPublishDetails(repoName);
+        ctx.publishDetails = await this.registryClient.getPublishDetails(appName);
       }
     };
     yield {
       title: "Docker login",
       task: async (ctx, task) => {
-        const regUrl = this.resolveRegistryUrl(ctx.publishDetails.repoName);
+        const publishDetails = ctx.publishDetails;
+        const regUrl = this.resolveRegistryUrl(publishDetails.repoName);
         await spawnCommand(
-          this.dockerLoginCmdText(ctx.publishDetails.userName, ctx.publishDetails.token, regUrl),
+          this.dockerLoginCmdText(publishDetails.userName, publishDetails.token, regUrl),
           new ListrTaskLogger(task, this.verbose ? 3 /* DEBUG */ : 0 /* INFO */)
         );
       },
@@ -82022,9 +82272,9 @@ var PublishVersionCommand = class {
     yield {
       title: "Docker build",
       task: async (ctx, task) => {
-        const details = ctx.publishDetails;
-        const regUrl = this.resolveRegistryUrl(details.repoName);
-        ctx.fullImageName = `${regUrl}/${details.imageName}:${details.imageVersion}`;
+        const publishDetails = ctx.publishDetails;
+        const regUrl = this.resolveRegistryUrl(publishDetails.repoName);
+        ctx.fullImageName = `${regUrl}/${publishDetails.imageName}:${publishDetails.imageVersion}`;
         await spawnCommand(
           this.dockerBuildCmdText(ctx.fullImageName),
           new ListrTaskLogger(task, this.verbose ? 3 /* DEBUG */ : 0 /* INFO */)
@@ -82046,6 +82296,7 @@ var PublishVersionCommand = class {
     yield {
       title: "Save publish details",
       task: async (ctx, task) => {
+        const publishDetails = ctx.publishDetails;
         const jsonSchemas = JSON.parse(ctx.contractText);
         const snapshot = {
           extensionId: kongJson.id,
@@ -82054,14 +82305,15 @@ var PublishVersionCommand = class {
           inputSchema: jsonSchemas.input,
           outputSchema: jsonSchemas.output,
           metadata: kongJson,
-          version: Number(ctx.publishDetails.imageVersion),
+          version: Number(publishDetails.imageVersion),
           notes,
           checkpoint: "",
           created: utcNow(DEFAULT_TIMEZONE),
           createdBy: ""
         };
         await this.managementClient.createExtensionSnapshot(kongJson.id, kongJson.name, snapshot);
-        task.output = `The version ${ctx.publishDetails.imageVersion} has been successfully published!`;
+        task.output = `The version ${publishDetails.imageVersion} has been successfully published!
+${joinUrlAndPath(this.profile.kongBaseUrl, "/extensions/aliases")}`;
       },
       rendererOptions: this.defaultRendererOptions
     };
@@ -82084,7 +82336,7 @@ var PublishVersionCommand = class {
     return `${engine} ${escapePathSpaces(mainPyPath)} --schema`;
   }
   getKotlinBuildCmdTask() {
-    return `${this.wslPrefix} ./gradlew build -Dquarkus.package.main-class=io.kong.sdkkotlin.JsonSchemaGeneratingQuarkusApp`;
+    return `${this.wslPrefix} ./gradlew build -Dquarkus.package.main-class=io.kong.sdkkotlin.QuarkusApp`;
   }
   getKotlinSchemaCmdTask() {
     return `${this.wslPrefix} java -Dquarkus-profile=local -jar build/quarkus-app/quarkus-run.jar --schema`;
@@ -82116,6 +82368,7 @@ function validateName(value) {
 }
 var SetAliasCommand = class {
   constructor(profile) {
+    this.profile = profile;
     const clientHeaderProvider = headerProvider(profile);
     this.publicClient = new PublicClient(profile.kongBaseUrl, clientHeaderProvider);
     this.managementClient = new ManagementClient(profile.kongBaseUrl, clientHeaderProvider);
@@ -82168,7 +82421,8 @@ var SetAliasCommand = class {
               updatedBy: ""
             };
             await this.publicClient.assignExtensionAlias(ctx.kongJson.id, alias);
-            task.output = "Please wait a moment for it to appear in the UI.";
+            task.output = `Please wait a moment for it to appear in the UI.
+${joinUrlAndPath(this.profile.kongBaseUrl, "/extensions/aliases")}`;
           },
           rendererOptions: { persistentOutput: true }
         }
@@ -82226,12 +82480,13 @@ async function main() {
   ).addOption(new Option("--profile <name>", "Configured Kong profile to use").default("default")).addOption(new Option("--verbose", "Show full logs during command execution")).addOption(new Option("--notes [text]", "Optional version notes").default("")).addOption(new Option("--schema <path>", "Schema file to use").default(null)).action(async (options) => {
     try {
       printProfile(options.profile);
+      const profile = getProfile(options.profile);
       const kongJson = getKongJson();
       await new PublishVersionCommand(
         getProfile(options.profile),
         options.verbose,
         options.schema
-      ).execute(kongJson.name, options.notes);
+      ).execute(`${parseTenant(profile.kongBaseUrl)}-k-extension-${kongJson.id}`, options.notes);
     } catch (ex) {
       printError("publish-version command failed", ex);
     }

package/package.json

@@ -1,13 +1,11 @@
 {
   "name": "@devkong/cli",
-  "version": "0.0.39",
+  "version": "0.0.41",
   "type": "commonjs",
   "main": "./index.js",
   "typings": "./index.d.ts",
   "bin": {
     "kong": "./index.js"
   },
-  "dependencies": {
-    "@napi-rs/keyring": "1.1.6"
-  }
+  "dependencies": {}
 }

package/packages/kong-cli/src/commands/publishVersionCommand.d.ts

@@ -1,6 +1,7 @@
 import { ListrTask } from "listr2";
 import { Profile } from "../common/profile";
 export declare class PublishVersionCommand {
+    private profile;
     private verbose;
     private contractPath;
     private readonly isWin;
@@ -10,8 +11,8 @@ export declare class PublishVersionCommand {
     private defaultRendererOptions;
     private get wslPrefix();
     constructor(profile: Profile, verbose?: boolean, contractPath?: string);
-    execute(repoName: string, notes: string): Promise<void>;
-    flowFactory(repoName: string, notes: string): Generator<ListrTask>;
+    execute(appName: string, notes: string): Promise<void>;
+    flowFactory(appName: string, notes: string): Generator<ListrTask>;
     private resolveRegistryUrl;
     private dockerBuildCmdText;
     private dockerPushCmdText;

package/packages/kong-cli/src/commands/setAliasCommand.d.ts

@@ -1,5 +1,6 @@
 import { Profile } from "../common/profile";
 export declare class SetAliasCommand {
+    private profile;
     private publicClient;
     private managementClient;
     constructor(profile: Profile);

package/packages/kong-cli/src/services/registryClient.d.ts

@@ -1,6 +1,6 @@
 import { UrlText, User } from "@kong/ts";
 import { HeaderProvider } from "./api";
-interface PublishDetails {
+export interface PublishDetails {
     repoName: string;
     imageName: string;
     imageVersion: string;
@@ -11,6 +11,5 @@ export declare class RegistryClient {
     private headerProvider;
     private readonly baseUrl;
     constructor(baseUrl: UrlText, headerProvider: HeaderProvider);
-    getPublishDetails(repoName: string): Promise<PublishDetails>;
+    getPublishDetails(appName: string): Promise<PublishDetails>;
 }
-export {};