@devkong/cli 0.0.67-alpha.26 → 0.0.67-alpha.28

package/index.js

@@ -47978,13 +47978,18 @@ var globalThisPolyfill = (function() {
   }
 })();
 
-// packages/kong-ts/src/lib/connect.ts
-var KONG_CONNECT_PORT = 41321;
-var KONG_CONNECT_BASE_URL = `http://localhost:${KONG_CONNECT_PORT}`;
-
 // packages/kong-ts/src/lib/cron.ts
 var import_cronstrue = __toESM(require_cronstrue());
 
+// packages/kong-ts/src/lib/guard.ts
+function notNull(value) {
+  if (value === void 0 || value === null) {
+    debugger;
+    throw new AppError(`The provided value must not be null, got ${value}`);
+  }
+  return value;
+}
+
 // packages/kong-ts/src/lib/jq.ts
 function jqFilter(value) {
   return value;
@@ -60729,7 +60734,7 @@ function uuidToJavaHashCode(uuid) {
   const hash = Number(mostSigBits >> 32n ^ mostSigBits ^ leastSigBits >> 32n ^ leastSigBits);
   return hash | 0;
 }
-function generateShortId() {
+function generateShortId2() {
   const sqids = new Sqids({
     minLength: 12,
     alphabet: "abcdefghijklmnopqrstuvwxyz0123456789"
@@ -60897,645 +60902,209 @@ var ConfigureCommand = class {
   }
 };
 
+// packages/kong-ts-contract/src/lib/appConnect.ts
+var APP_CONNECT_PORT = 41321;
+var APP_CONNECT_BASE_URL = `http://localhost:${APP_CONNECT_PORT}`;
+
 // packages/kong-cli/src/commands/connectCommand.ts
-var import_child_process2 = require("child_process");
-var import_fs3 = __toESM(require("fs"));
+var import_child_process3 = require("child_process");
+var import_fs5 = __toESM(require("fs"));
 var import_http4 = __toESM(require("http"));
-var import_os2 = __toESM(require("os"));
+var import_os3 = __toESM(require("os"));
+var import_path6 = __toESM(require("path"));
+
+// packages/kong-cli/src/common/cli.ts
+var import_fs3 = __toESM(require("fs"));
 var import_path4 = __toESM(require("path"));
+function getPresetVersion() {
+  const packageJsonPath = import_path4.default.join(__dirname, "package.json");
+  if (!import_fs3.default.existsSync(packageJsonPath)) {
+    throw new AppError(`package.json file was not found at path: ${packageJsonPath}`);
+  }
+  return require(packageJsonPath).version;
+}
 
-// packages/kong-cli/src/services/api.ts
-var import_keyring2 = __toESM(require_keyring());
+// packages/kong-cli/src/commands/generateCommand.ts
+var import_create_nx_workspace = require("create-nx-workspace");
 
-// node_modules/jwt-decode/build/esm/index.js
-var InvalidTokenError = class extends Error {
-};
-InvalidTokenError.prototype.name = "InvalidTokenError";
-function b64DecodeUnicode(str) {
-  return decodeURIComponent(atob(str).replace(/(.)/g, (m, p) => {
-    let code = p.charCodeAt(0).toString(16).toUpperCase();
-    if (code.length < 2) {
-      code = "0" + code;
+// packages/kong-cli/src/common/kongJson.ts
+var import_ajv = __toESM(require_ajv());
+var import_fs4 = __toESM(require("fs"));
+
+// packages/kong-cli/src/common/kongJsonSchema.ts
+var KONG_JSON_SCHEMA = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  type: "object",
+  properties: {
+    id: {
+      type: "string"
+    },
+    name: {
+      type: "string"
+    },
+    sdk: {
+      type: "string",
+      enum: ["python", "kotlin"]
+    },
+    category: {
+      type: "string"
+    },
+    settings: {
+      type: "object",
+      properties: {
+        input: {
+          type: "object",
+          properties: {
+            filter: {
+              type: "string"
+            },
+            schema: {
+              $ref: "http://json-schema.org/draft-07/schema#"
+            }
+          },
+          required: ["schema", "filter"]
+        },
+        output: {
+          type: "object",
+          properties: {
+            filter: {
+              type: "string"
+            },
+            schema: {
+              $ref: "http://json-schema.org/draft-07/schema#"
+            }
+          },
+          required: ["schema", "filter"]
+        },
+        invoke: {
+          type: "object",
+          properties: {
+            prefix: {
+              type: "string"
+            },
+            cache: {
+              type: "object",
+              properties: {
+                enabled: {
+                  type: "boolean"
+                },
+                key: {
+                  type: ["string"]
+                },
+                ttl: {
+                  type: "string"
+                },
+                onFailure: {
+                  type: "string",
+                  enum: ["skip", "retry"]
+                }
+              },
+              required: ["enabled", "key", "ttl", "onFailure"]
+            },
+            retry: {
+              type: "object",
+              properties: {
+                maxAttempts: {
+                  type: "number"
+                },
+                attemptDelay: {
+                  type: "string"
+                },
+                attemptTimeout: {
+                  type: "string"
+                }
+              },
+              required: ["maxAttempts", "attemptDelay", "attemptTimeout"]
+            },
+            circuitBreaker: {
+              type: "object",
+              properties: {
+                enabled: {
+                  type: "boolean"
+                },
+                requestVolumeThreshold: {
+                  type: "number"
+                },
+                failureRatio: {
+                  type: "number"
+                },
+                successThreshold: {
+                  type: "number"
+                }
+              },
+              required: ["enabled", "requestVolumeThreshold", "failureRatio", "successThreshold"]
+            }
+          }
+        }
+      },
+      additionalProperties: false
     }
-    return "%" + code;
-  }));
-}
-function base64UrlDecode(str) {
-  let output = str.replace(/-/g, "+").replace(/_/g, "/");
-  switch (output.length % 4) {
-    case 0:
-      break;
-    case 2:
-      output += "==";
-      break;
-    case 3:
-      output += "=";
-      break;
-    default:
-      throw new Error("base64 string is not of the correct length");
+  },
+  additionalProperties: false,
+  required: ["id", "name", "sdk", "category"]
+};
+
+// packages/kong-cli/src/common/kongJson.ts
+var ajv = new import_ajv.default();
+var validate2 = ajv.compile(KONG_JSON_SCHEMA);
+var SUPPORTED_SDK = ["kotlin", "python"];
+function validateKongJson(kongJson) {
+  if (isEmpty(kongJson.id)) {
+    throw new AppError(
+      "The `id` field should not be empty. Please provide a valid identifier in kong.json."
+    );
   }
-  try {
-    return b64DecodeUnicode(output);
-  } catch (err) {
-    return atob(output);
+  if (isEmpty(kongJson.category)) {
+    throw new AppError(
+      "The `category` field should not be empty. Please provide a category value in kong.json."
+    );
   }
-}
-function jwtDecode(token, options) {
-  if (typeof token !== "string") {
-    throw new InvalidTokenError("Invalid token specified: must be a string");
+  if (!/^[a-z][a-z0-9]{11}$/.test(kongJson.id)) {
+    throw new AppError(
+      "The id must be exactly 12 characters long and consist of alphanumeric characters (lowercase letters and digits). It must start with a letter. Ensure the ID does not exceed 12 characters. Please provide a valid identifier in kong.json"
+    );
   }
-  options || (options = {});
-  const pos = options.header === true ? 0 : 1;
-  const part = token.split(".")[pos];
-  if (typeof part !== "string") {
-    throw new InvalidTokenError(`Invalid token specified: missing part #${pos + 1}`);
+  if (!SUPPORTED_SDK.includes(kongJson.sdk)) {
+    throw new AppError(
+      `Unexpected SDK value: ${kongJson.sdk}. Supported SDK: ${SUPPORTED_SDK}.Please provide a valid identifier in kong.json.`
+    );
   }
-  let decoded;
-  try {
-    decoded = base64UrlDecode(part);
-  } catch (e) {
-    throw new InvalidTokenError(`Invalid token specified: invalid base64 for part #${pos + 1} (${e.message})`);
+  if (isEmpty(kongJson.name)) {
+    throw new AppError(
+      "The `name` field should not be empty. Please provide a valid name in kong.json."
+    );
+  }
+  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(kongJson.name)) {
+    throw new AppError(
+      "The `name` should only contain lowercase letters, digits, and dashes. Dashes can only appear between alphanumeric characters, and the name cannot start or end with a dash.Please provide a valid name in kong.json."
+    );
+  }
+  const isValid2 = validate2(kongJson);
+  if (!isValid2) {
+    throw new AppError(
+      "The provided `kong.json` does not follow the expected JSON schema. Errors: \n" + prettyJsonObject(validate2.errors || [])
+    );
   }
+  return kongJson;
+}
+function getKongJson() {
+  const kongJsonPath = resolveProjectPath("kong.json");
   try {
-    return JSON.parse(decoded);
-  } catch (e) {
-    throw new InvalidTokenError(`Invalid token specified: invalid json for part #${pos + 1} (${e.message})`);
-  }
-}
-
-// packages/kong-cli/src/services/api.ts
-function requestConfigProvider(profile) {
-  const cached = {
-    headers: {
-      "Content-Type": "application/json",
-      "X-App-Tenant": parseTenant(profile.kongBaseUrl)
-    }
-  };
-  return async () => {
-    if (cached.headers?.Authorization) {
-      try {
-        const auth = cached.headers.Authorization;
-        const accessToken = auth.split("Bearer ")[1]?.trim();
-        if (accessToken) {
-          const decoded = jwtDecode(accessToken);
-          if (decoded.exp !== void 0) {
-            const nowSeconds = Date.now() / 1e3;
-            if (decoded.exp > nowSeconds + 60) {
-              return cached;
-            }
-          }
-        }
-      } catch (ex) {
-        console.warn("failed to use cached token, fetching new one", ex);
-      }
-    }
-    const url2 = joinUrlAndPath(
-      profile.kongBaseUrl,
-      "api/keycloak/realms/kong/protocol/openid-connect/token"
-    );
-    const entry = new import_keyring2.Entry(profile.kongBaseUrl, profile.userName);
-    const password = entry.getPassword();
-    if (!password) {
-      throw new Error("No password found in keyring for user: " + profile.userName);
-    }
-    const params = new URLSearchParams({
-      grant_type: "password",
-      client_id: "kong-web",
-      username: profile.userName,
-      password
-    });
-    const response = await axios_default.post(url2, params, {
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded"
-      }
-    });
-    cached.headers = {
-      ...cached.headers,
-      ["Authorization"]: `Bearer ${response.data.access_token}`
-    };
-    return cached;
-  };
-}
-
-// packages/kong-cli/src/services/managementClient.ts
-var ManagementClient = class {
-  constructor(kongBaseUrl, requestConfigProvider2) {
-    this.requestConfigProvider = requestConfigProvider2;
-    this.baseUrl = joinUrlAndPath(kongBaseUrl, "/api/management");
-  }
-  async updateExtension(extension) {
-    const url2 = joinUrlAndPath(this.baseUrl, "v1/extensions");
-    await axios_default.put(url2, extension, await this.requestConfigProvider());
-  }
-  async createExtensionSnapshot(extensionId, snapshot) {
-    const url2 = joinUrlAndPath(this.baseUrl, "v1/extensions", extensionId, "snapshots");
-    await axios_default.post(url2, snapshot, await this.requestConfigProvider());
-  }
-  async getExtensionSnapshot(extensionId, extensionSnapshotVersion) {
-    const url2 = joinUrlAndPath(
-      this.baseUrl,
-      "v1/extensions",
-      extensionId,
-      "snapshots",
-      extensionSnapshotVersion
-    );
-    return (await axios_default.get(url2, await this.requestConfigProvider())).data;
-  }
-  async getExtensionSnapshotVersions(extensionId) {
-    const url2 = joinUrlAndPath(this.baseUrl, "v1/extensions", extensionId, "/snapshots/versions");
-    return (await axios_default.get(url2, await this.requestConfigProvider())).data;
-  }
-  async getExtensionSnapshotAliases(extensionId) {
-    const url2 = joinUrlAndPath(this.baseUrl, "v1/extensions", extensionId, "/aliases");
-    return (await axios_default.get(url2, await this.requestConfigProvider())).data;
-  }
-  async getDocumentSnapshotVersions(documentId) {
-    const url2 = joinUrlAndPath(this.baseUrl, "v1/documents", documentId, "/snapshots/versions");
-    return (await axios_default.get(url2, await this.requestConfigProvider())).data;
-  }
-  async getProcessAliases(documentId) {
-    const url2 = joinUrlAndPath(this.baseUrl, "v1/processes", documentId, "/aliases");
-    return (await axios_default.get(url2, await this.requestConfigProvider())).data;
-  }
-  async getAuditLog(objectType2, objectId, createdAfter) {
-    const url2 = joinUrlAndPath(this.baseUrl, "v1/audit");
-    const config = await this.requestConfigProvider();
-    const response = await axios_default.get(url2, {
-      ...config,
-      params: { ...config.params, objectType: objectType2, objectId, createdAfter }
-    });
-    return response.data;
-  }
-};
-
-// packages/kong-cli/src/services/registryClient.ts
-var RegistryClient = class {
-  constructor(kongBaseUrl, requestConfigProvider2) {
-    this.requestConfigProvider = requestConfigProvider2;
-    this.baseUrl = joinUrlAndPath(kongBaseUrl, "/api/registry");
-  }
-  async getPublishDetails(appName) {
-    const url2 = joinUrlAndPath(this.baseUrl, "v1/repository", appName, "publish/details");
-    return (await axios_default.post(url2, {}, await this.requestConfigProvider())).data;
-  }
-};
-
-// packages/kong-cli/src/commands/connectCommand.ts
-var DOCKERFILE = `# syntax=docker/dockerfile:1
-FROM --platform=linux/amd64 python:3.13.1-slim-bookworm
-
-ENV APP_DIR=/deployments/app \\
-    PYTHONUNBUFFERED=1 \\
-    PYTHONDONTWRITEBYTECODE=1
-
-WORKDIR $APP_DIR
-
-COPY --chown=1001:root ./requirements.txt ./requirements.txt
-RUN pip install --upgrade pip && \\
-    pip install -r requirements.txt
-
-COPY --chown=1001:root ./src ./src
-
-RUN useradd --uid 1001 --gid root --create-home app \\
-    && chown 1001:root $APP_DIR \\
-    && chmod "g+rwX" $APP_DIR
-
-USER 1001
-
-CMD ["python", "./src/main.py"]
-`;
-var PYPROJECT = `[tool.pytest.ini_options]
-asyncio_mode = "auto"
-asyncio_default_fixture_loop_scope = "function"
-`;
-var TEST_DEPENDENCIES = ["pytest==9.1.1", "pytest-asyncio==1.4.0"];
-var ConnectCommand = class {
-  constructor(profileName, profile) {
-    this.profileName = profileName;
-    this.profile = profile;
-    this.isWin = process.platform === "win32";
-    const provider = requestConfigProvider(profile);
-    this.registryClient = new RegistryClient(profile.kongBaseUrl, provider);
-    this.managementClient = new ManagementClient(profile.kongBaseUrl, provider);
-  }
-  async execute() {
-    const server = import_http4.default.createServer((request, response) => {
-      this.handle(request, response).catch((ex) => {
-        console.error("request failed", ex);
-        if (!response.headersSent) {
-          this.json(response, 500, { error: String(ex) });
-        }
-      });
-    });
-    server.listen(KONG_CONNECT_PORT, () => {
-      console.info(
-        `kong connect is listening on http://localhost:${KONG_CONNECT_PORT} (profile=${this.profileName}, baseUrl=${this.profile.kongBaseUrl})`
-      );
-      console.info("keep this terminal open while working in the kong ui; ctrl+c to stop");
-    });
-  }
-  async handle(request, response) {
-    response.setHeader("Access-Control-Allow-Origin", "*");
-    response.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
-    response.setHeader("Access-Control-Allow-Headers", "Content-Type");
-    if (request.method === "OPTIONS") {
-      response.writeHead(204);
-      response.end();
-      return;
-    }
-    const url2 = new URL(request.url ?? "/", `http://localhost:${KONG_CONNECT_PORT}`);
-    if (request.method === "GET" && url2.pathname === "/v1/profile") {
-      this.json(response, 200, this.profileInfo());
-      return;
-    }
-    if (request.method === "POST" && url2.pathname === "/v1/tests") {
-      const body = await this.readBody(request);
-      this.json(response, 200, await this.runTests(body));
-      return;
-    }
-    if (request.method === "POST" && url2.pathname === "/v1/deployments") {
-      const body = await this.readBody(request);
-      this.json(response, 200, await this.deploy(body));
-      return;
-    }
-    this.json(response, 404, { error: `unknown route ${request.method} ${url2.pathname}` });
-  }
-  profileInfo() {
-    return {
-      profile: this.profileName,
-      baseUrl: this.profile.kongBaseUrl,
-      userName: this.profile.userName,
-      docker: !(0, import_child_process2.spawnSync)("docker", ["--version"]).error,
-      python: !(0, import_child_process2.spawnSync)(this.pythonBin(), ["--version"]).error
-    };
-  }
-  /** Runs only src/main_test.py in a fresh venv and returns the raw output. */
-  async runTests(request) {
-    const workDir = this.materialize(request.files);
-    try {
-      const log = [];
-      const prepared = await this.prepareVenv(workDir, log);
-      if (prepared.exitCode !== 0) {
-        return { passed: false, output: log.join("\n") };
-      }
-      const result = await this.run(
-        this.venvPython(workDir),
-        ["-m", "pytest", import_path4.default.join("src", "main_test.py"), "-v"],
-        workDir
-      );
-      log.push(result.output);
-      return { passed: result.exitCode === 0, output: log.join("\n") };
-    } finally {
-      import_fs3.default.rmSync(workDir, { recursive: true, force: true });
-    }
-  }
-  /**
-   * The client-side twin of the kong-build pipeline: docker build + push from
-   * this machine (requirements.txt applied), schema generated locally with
-   * `main.py --schema`, then the snapshot registered in kong-management.
-   */
-  async deploy(request) {
-    const workDir = this.materialize(request.files);
-    try {
-      const log = [];
-      import_fs3.default.writeFileSync(import_path4.default.join(workDir, "Dockerfile"), DOCKERFILE);
-      const prepared = await this.prepareVenv(workDir, log);
-      if (prepared.exitCode !== 0) {
-        throw new Error(`dependency install failed:
-${log.join("\n")}`);
-      }
-      const schema = await this.run(
-        this.venvPython(workDir),
-        [import_path4.default.join("src", "main.py"), "--schema"],
-        workDir
-      );
-      if (schema.exitCode !== 0) {
-        throw new Error(`schema generation failed:
-${schema.output}`);
-      }
-      const contract = JSON.parse(schema.output);
-      const tenant = parseTenant(this.profile.kongBaseUrl);
-      const publishDetails = await this.registryClient.getPublishDetails(
-        `${tenant}-k-extension-${request.extensionId}`
-      );
-      const registryUrl = publishDetails.repoName === "docker-registry:5000" ? "localhost:5000" : publishDetails.repoName;
-      const imageName = `${registryUrl}/${publishDetails.imageName}:${publishDetails.imageVersion}`;
-      for (const step of [
-        {
-          title: "docker login",
-          command: "docker",
-          args: ["login", "-u", publishDetails.userName, "--password-stdin", registryUrl],
-          stdin: publishDetails.token
-        },
-        {
-          title: "docker build",
-          command: "docker",
-          args: ["build", "--network=host", "-t", imageName, "-f", "Dockerfile", "."]
-        },
-        { title: "docker push", command: "docker", args: ["push", imageName] }
-      ]) {
-        log.push(`> ${step.title}`);
-        const result = await this.run(step.command, step.args, workDir, step.stdin);
-        log.push(result.output);
-        if (result.exitCode !== 0) {
-          throw new Error(`${step.title} failed:
-${log.join("\n")}`);
-        }
-      }
-      const version = Number(publishDetails.imageVersion);
-      await this.managementClient.createExtensionSnapshot(
-        request.extensionId,
-        this.snapshotFor(request, version, contract)
-      );
-      log.push(`the version ${version} has been successfully published!`);
-      return { version, output: log.join("\n") };
-    } finally {
-      import_fs3.default.rmSync(workDir, { recursive: true, force: true });
-    }
-  }
-  snapshotFor(request, version, contract) {
-    return {
-      extensionId: request.extensionId,
-      extensionName: request.extensionName,
-      sdk: "python",
-      inputSchema: contract.input,
-      outputSchema: contract.output,
-      metadata: {
-        id: request.extensionId,
-        name: request.extensionName,
-        sdk: "python",
-        settings: {
-          input: { filter: jqFilter(""), schema: contract.input },
-          output: { filter: jqFilter(""), schema: contract.output }
-        }
-      },
-      version,
-      notes: request.notes ?? "",
-      checkpoint: "",
-      created: utcNow(DEFAULT_TIMEZONE),
-      createdBy: ""
-    };
-  }
-  /** Writes the bundle to a fresh temp folder, decoding binary entries. */
-  materialize(files) {
-    const workDir = import_fs3.default.mkdtempSync(import_path4.default.join(import_os2.default.tmpdir(), `kong-connect-${generateShortId()}-`));
-    for (const file of files) {
-      const target = import_path4.default.resolve(workDir, file.name);
-      if (!target.startsWith(workDir)) {
-        continue;
-      }
-      import_fs3.default.mkdirSync(import_path4.default.dirname(target), { recursive: true });
-      import_fs3.default.writeFileSync(
-        target,
-        file.binary === true ? Buffer.from(file.content, "base64") : file.content
-      );
-    }
-    import_fs3.default.writeFileSync(import_path4.default.join(workDir, "pyproject.toml"), PYPROJECT);
-    return workDir;
-  }
-  async prepareVenv(workDir, log) {
-    const venv = await this.run(this.pythonBin(), ["-m", "venv", "--clear", ".venv"], workDir);
-    log.push(venv.output);
-    if (venv.exitCode !== 0) {
-      return venv;
-    }
-    const install = await this.run(
-      this.venvPython(workDir),
-      [
-        "-m",
-        "pip",
-        "install",
-        "--default-timeout=120",
-        "-r",
-        "requirements.txt",
-        ...TEST_DEPENDENCIES
-      ],
-      workDir
-    );
-    log.push(install.output);
-    return install;
-  }
-  pythonBin() {
-    return (0, import_child_process2.spawnSync)("python", ["--version"]).error ? "python3" : "python";
-  }
-  venvPython(workDir) {
-    return this.isWin ? import_path4.default.join(workDir, ".venv", "Scripts", "python.exe") : import_path4.default.join(workDir, ".venv", "bin", "python");
-  }
-  run(command, args, cwd, stdin) {
-    return new Promise((resolve2) => {
-      const child = (0, import_child_process2.spawn)(command, args, { cwd });
-      const chunks = [];
-      child.stdout.on("data", (data) => chunks.push(String(data)));
-      child.stderr.on("data", (data) => chunks.push(String(data)));
-      child.on("error", (error) => resolve2({ exitCode: -1, output: String(error) }));
-      child.on("close", (exitCode) => resolve2({ exitCode: exitCode ?? -1, output: chunks.join("") }));
-      if (stdin !== void 0) {
-        child.stdin.write(stdin);
-      }
-      child.stdin.end();
-    });
-  }
-  readBody(request) {
-    return new Promise((resolve2, reject) => {
-      const chunks = [];
-      request.on("data", (chunk) => chunks.push(chunk));
-      request.on("error", reject);
-      request.on("end", () => {
-        try {
-          resolve2(JSON.parse(Buffer.concat(chunks).toString("utf-8") || "{}"));
-        } catch (ex) {
-          reject(ex instanceof Error ? ex : new Error(String(ex)));
-        }
-      });
-    });
-  }
-  json(response, status, body) {
-    response.writeHead(status, { "Content-Type": "application/json" });
-    response.end(JSON.stringify(body));
-  }
-};
-
-// packages/kong-cli/src/commands/generateCommand.ts
-var import_create_nx_workspace = require("create-nx-workspace");
-
-// packages/kong-cli/src/common/kongJson.ts
-var import_ajv = __toESM(require_ajv());
-var import_fs4 = __toESM(require("fs"));
-
-// packages/kong-cli/src/common/kongJsonSchema.ts
-var KONG_JSON_SCHEMA = {
-  $schema: "http://json-schema.org/draft-07/schema#",
-  type: "object",
-  properties: {
-    id: {
-      type: "string"
-    },
-    name: {
-      type: "string"
-    },
-    sdk: {
-      type: "string",
-      enum: ["python", "kotlin"]
-    },
-    category: {
-      type: "string"
-    },
-    settings: {
-      type: "object",
-      properties: {
-        input: {
-          type: "object",
-          properties: {
-            filter: {
-              type: "string"
-            },
-            schema: {
-              $ref: "http://json-schema.org/draft-07/schema#"
-            }
-          },
-          required: ["schema", "filter"]
-        },
-        output: {
-          type: "object",
-          properties: {
-            filter: {
-              type: "string"
-            },
-            schema: {
-              $ref: "http://json-schema.org/draft-07/schema#"
-            }
-          },
-          required: ["schema", "filter"]
-        },
-        invoke: {
-          type: "object",
-          properties: {
-            prefix: {
-              type: "string"
-            },
-            cache: {
-              type: "object",
-              properties: {
-                enabled: {
-                  type: "boolean"
-                },
-                key: {
-                  type: ["string"]
-                },
-                ttl: {
-                  type: "string"
-                },
-                onFailure: {
-                  type: "string",
-                  enum: ["skip", "retry"]
-                }
-              },
-              required: ["enabled", "key", "ttl", "onFailure"]
-            },
-            retry: {
-              type: "object",
-              properties: {
-                maxAttempts: {
-                  type: "number"
-                },
-                attemptDelay: {
-                  type: "string"
-                },
-                attemptTimeout: {
-                  type: "string"
-                }
-              },
-              required: ["maxAttempts", "attemptDelay", "attemptTimeout"]
-            },
-            circuitBreaker: {
-              type: "object",
-              properties: {
-                enabled: {
-                  type: "boolean"
-                },
-                requestVolumeThreshold: {
-                  type: "number"
-                },
-                failureRatio: {
-                  type: "number"
-                },
-                successThreshold: {
-                  type: "number"
-                }
-              },
-              required: ["enabled", "requestVolumeThreshold", "failureRatio", "successThreshold"]
-            }
-          }
-        }
-      },
-      additionalProperties: false
-    }
-  },
-  additionalProperties: false,
-  required: ["id", "name", "sdk", "category"]
-};
-
-// packages/kong-cli/src/common/kongJson.ts
-var ajv = new import_ajv.default();
-var validate2 = ajv.compile(KONG_JSON_SCHEMA);
-var SUPPORTED_SDK = ["kotlin", "python"];
-function validateKongJson(kongJson) {
-  if (isEmpty(kongJson.id)) {
-    throw new AppError(
-      "The `id` field should not be empty. Please provide a valid identifier in kong.json."
-    );
-  }
-  if (isEmpty(kongJson.category)) {
-    throw new AppError(
-      "The `category` field should not be empty. Please provide a category value in kong.json."
-    );
-  }
-  if (!/^[a-z][a-z0-9]{11}$/.test(kongJson.id)) {
-    throw new AppError(
-      "The id must be exactly 12 characters long and consist of alphanumeric characters (lowercase letters and digits). It must start with a letter. Ensure the ID does not exceed 12 characters. Please provide a valid identifier in kong.json"
-    );
-  }
-  if (!SUPPORTED_SDK.includes(kongJson.sdk)) {
-    throw new AppError(
-      `Unexpected SDK value: ${kongJson.sdk}. Supported SDK: ${SUPPORTED_SDK}.Please provide a valid identifier in kong.json.`
-    );
-  }
-  if (isEmpty(kongJson.name)) {
-    throw new AppError(
-      "The `name` field should not be empty. Please provide a valid name in kong.json."
-    );
-  }
-  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(kongJson.name)) {
-    throw new AppError(
-      "The `name` should only contain lowercase letters, digits, and dashes. Dashes can only appear between alphanumeric characters, and the name cannot start or end with a dash.Please provide a valid name in kong.json."
-    );
-  }
-  const isValid2 = validate2(kongJson);
-  if (!isValid2) {
-    throw new AppError(
-      "The provided `kong.json` does not follow the expected JSON schema. Errors: \n" + prettyJsonObject(validate2.errors || [])
-    );
-  }
-  return kongJson;
-}
-function getKongJson() {
-  const kongJsonPath = resolveProjectPath("kong.json");
-  try {
-    const fileContent = import_fs4.default.readFileSync(kongJsonPath, "utf-8");
-    const kongJson = JSON.parse(fileContent);
-    return validateKongJson(kongJson);
-  } catch (ex) {
-    if (ex instanceof SyntaxError) {
-      throw new AppError(`Error parsing kong.json: ${ex.message}`);
-    }
-    throw ex;
+    const fileContent = import_fs4.default.readFileSync(kongJsonPath, "utf-8");
+    const kongJson = JSON.parse(fileContent);
+    return validateKongJson(kongJson);
+  } catch (ex) {
+    if (ex instanceof SyntaxError) {
+      throw new AppError(`Error parsing kong.json: ${ex.message}`);
+    }
+    throw ex;
   }
 }
 
 // packages/kong-cli/src/commands/generateCommand.ts
 var GenerateCommand = class {
   async execute(extensionName, sdk, presetVersion, template2) {
-    const id = generateShortId();
+    const id = generateShortId2();
     const variant = sdk === "python" ? template2 ?? await this.promptTemplate() : "basic";
     validateKongJson({
       id,
@@ -61586,7 +61155,7 @@ var eventemitter3_default = import_index.default;
 // node_modules/listr2/dist/index.mjs
 var import_node_util11 = require("node:util");
 var import_util4 = require("util");
-var import_os3 = require("os");
+var import_os2 = require("os");
 var import_string_decoder = require("string_decoder");
 var import_stream5 = require("stream");
 var import_rfdc = __toESM(require_rfdc(), 1);
@@ -61778,12 +61347,12 @@ var ListrLogger = class {
   }
   format(level, message2, options) {
     if (!Array.isArray(message2)) message2 = [message2];
-    message2 = this.splat(message2.shift(), ...message2).toString().split(import_os3.EOL).filter((m) => !m || m.trim() !== "").map((m) => {
+    message2 = this.splat(message2.shift(), ...message2).toString().split(import_os2.EOL).filter((m) => !m || m.trim() !== "").map((m) => {
       return this.style(level, this.fields(m, {
         prefix: Array.isArray(options?.prefix) ? options.prefix : [options?.prefix],
         suffix: Array.isArray(options?.suffix) ? options.suffix : [options?.suffix]
       }));
-    }).join(import_os3.EOL);
+    }).join(import_os2.EOL);
     return message2;
   }
   style(level, message2) {
@@ -61899,20 +61468,20 @@ var ProcessOutput = class {
       };
     }).filter((message2) => message2.entry);
     if (output.length > 0) {
-      if (this.options.leaveEmptyLine) this.stdout.write(import_os3.EOL);
+      if (this.options.leaveEmptyLine) this.stdout.write(import_os2.EOL);
       output.forEach((message2) => {
-        (message2.stream ?? this.stdout).write(message2.entry + import_os3.EOL);
+        (message2.stream ?? this.stdout).write(message2.entry + import_os2.EOL);
       });
     }
     this.stream.stdout.write(ANSI_ESCAPE_CODES.CURSOR_SHOW);
     this.active = false;
   }
   toStdout(buffer, eol = true) {
-    if (eol) buffer = buffer + import_os3.EOL;
+    if (eol) buffer = buffer + import_os2.EOL;
     return this.stream.stdout.write(buffer);
   }
   toStderr(buffer, eol = true) {
-    if (eol) buffer = buffer + import_os3.EOL;
+    if (eol) buffer = buffer + import_os2.EOL;
     return this.stream.stderr.write(buffer);
   }
 };
@@ -62124,7 +61693,7 @@ var DefaultRenderer = class DefaultRenderer2 {
       if (render.length > 0) render.push("");
       render.push(...renderPrompt);
     }
-    return render.join(import_os3.EOL);
+    return render.join(import_os2.EOL);
   }
   style(task, output = false) {
     const rendererOptions = this.cache.rendererOptions.get(task.id);
@@ -62157,7 +61726,7 @@ var DefaultRenderer = class DefaultRenderer2 {
     const columns = (process.stdout.columns ?? 80) - level * this.options.indentation - 2;
     switch (this.options.formatOutput) {
       case "truncate":
-        parsed = message2.split(import_os3.EOL).map((s, i) => {
+        parsed = message2.split(import_os2.EOL).map((s, i) => {
           return this.truncate(this.indent(s, i), columns);
         });
         break;
@@ -62165,7 +61734,7 @@ var DefaultRenderer = class DefaultRenderer2 {
         parsed = this.wrap(message2, columns, {
           hard: true,
           trim: false
-        }).split(import_os3.EOL).map((s, i) => this.indent(s, i));
+        }).split(import_os2.EOL).map((s, i) => this.indent(s, i));
         break;
       default:
         throw new ListrRendererError("Format option for the renderer is wrong.");
@@ -62284,7 +61853,7 @@ var DefaultRenderer = class DefaultRenderer2 {
       this.buffer.bottom.set(task.id, new ProcessOutputBuffer({ limit: typeof rendererTaskOptions.bottomBar === "number" ? rendererTaskOptions.bottomBar : 1 }));
       task.on("OUTPUT", (output) => {
         const data = this.dump(task, -1, "OUTPUT", output);
-        this.buffer.bottom.get(task.id).write(data.join(import_os3.EOL));
+        this.buffer.bottom.get(task.id).write(data.join(import_os2.EOL));
       });
       task.on("STATE", (state) => {
         switch (state) {
@@ -63356,144 +62925,49 @@ var ListrTaskLogger = class {
       this.task.output = message2;
     }
   }
-  warn(message2) {
-    if (this.logLevel >= 1 /* WARN */) {
-      this.task.output = message2;
-    }
-  }
-};
-
-// packages/kong-cli/src/commands/installCommand.ts
-var InstallCommand = class {
-  constructor(verbose) {
-    this.verbose = verbose;
-  }
-  async execute(workspaceDirectory) {
-    await new Listr([
-      {
-        title: "installing dependencies with pip",
-        task: async (_2, task) => {
-          const scriptPath = this.scriptPath();
-          await spawnCommandWithArgs(
-            escapePathSpaces(scriptPath),
-            [escapePathSpaces(workspaceDirectory)],
-            new ListrTaskLogger(task, this.verbose ? 3 /* DEBUG */ : 0 /* INFO */),
-            true
-          );
-        },
-        rendererOptions: {
-          bottomBar: this.verbose ? Infinity : true,
-          persistentOutput: true
-        }
-      }
-    ]).run();
-  }
-  scriptPath() {
-    const scriptName = "python-install";
-    if (process.platform === "win32") {
-      return import_path5.default.join(__dirname, "assets", `${scriptName}.bat`);
-    }
-    return import_path5.default.join(__dirname, "assets", `${scriptName}.sh`);
-  }
-};
-
-// packages/kong-cli/src/commands/listAliasesCommand.ts
-var ListAliasesCommand = class {
-  constructor(profile, verbose) {
-    this.profile = profile;
-    this.verbose = verbose;
-    this.managementClient = new ManagementClient(
-      this.profile.kongBaseUrl,
-      requestConfigProvider(profile)
-    );
-  }
-  async execute(processId) {
-    await new Listr(
-      [
-        {
-          title: processId ? `list process aliases (${processId})` : "list extension aliases",
-          task: async (ctx, task) => {
-            const aliases = processId ? await this.managementClient.getProcessAliases(processId) : await this.managementClient.getExtensionSnapshotAliases(getKongJson().id);
-            if (aliases.length === 0) {
-              task.output = "no aliases available";
-            } else {
-              const result = [];
-              for (const alias of aliases) {
-                for (const item of alias.use) {
-                  result.push(
-                    `${alias.name}, ${item.snapshot.version}, ${item.balance ? `${item.balance}%` : "shadow"}`
-                  );
-                }
-              }
-              task.output = result.join("\n");
-            }
-          },
-          rendererOptions: {
-            persistentOutput: true
-          }
-        }
-      ],
-      {
-        renderer: "default",
-        rendererOptions: {
-          logger: new ListrLogger({
-            processOutput: new ProcessOutput(process.stderr, process.stderr)
-          })
-        }
-      }
-    ).run();
-  }
+  warn(message2) {
+    if (this.logLevel >= 1 /* WARN */) {
+      this.task.output = message2;
+    }
+  }
 };
 
-// packages/kong-cli/src/commands/listVersionsCommand.ts
-var ListVersionsCommand = class {
-  constructor(profile, verbose) {
+// packages/kong-cli/src/commands/installCommand.ts
+var InstallCommand = class {
+  constructor(verbose) {
     this.verbose = verbose;
-    this.managementClient = new ManagementClient(
-      profile.kongBaseUrl,
-      requestConfigProvider(profile)
-    );
   }
-  async execute(processId) {
-    await new Listr(
-      [
-        {
-          title: processId ? `list process snapshot versions (${processId})` : "list extension snapshot versions",
-          task: async (ctx, task) => {
-            const versions = processId ? await this.managementClient.getDocumentSnapshotVersions(
-              processId
-            ) : await this.managementClient.getExtensionSnapshotVersions(getKongJson().id);
-            if (versions.length === 0) {
-              task.output = "no versions available";
-            } else {
-              const result = [];
-              for (const ver of versions) {
-                result.push(
-                  `${ver.version}, ${ver.created}, ${ver.createdBy}, ${ver.notes || "no notes"}`
-                );
-              }
-              task.output = result.join("\n");
-            }
-          },
-          rendererOptions: {
-            persistentOutput: true
-          }
-        }
-      ],
+  async execute(workspaceDirectory) {
+    await new Listr([
       {
-        renderer: "default",
+        title: "installing dependencies with pip",
+        task: async (_2, task) => {
+          const scriptPath = this.scriptPath();
+          await spawnCommandWithArgs(
+            escapePathSpaces(scriptPath),
+            [escapePathSpaces(workspaceDirectory)],
+            new ListrTaskLogger(task, this.verbose ? 3 /* DEBUG */ : 0 /* INFO */),
+            true
+          );
+        },
         rendererOptions: {
-          logger: new ListrLogger({
-            processOutput: new ProcessOutput(process.stderr, process.stderr)
-          })
+          bottomBar: this.verbose ? Infinity : true,
+          persistentOutput: true
         }
       }
-    ).run();
+    ]).run();
+  }
+  scriptPath() {
+    const scriptName = "python-install";
+    if (process.platform === "win32") {
+      return import_path5.default.join(__dirname, "assets", `${scriptName}.bat`);
+    }
+    return import_path5.default.join(__dirname, "assets", `${scriptName}.sh`);
   }
 };
 
 // packages/kong-cli/src/commands/publishVersionCommand.ts
-var import_child_process3 = require("child_process");
+var import_child_process2 = require("child_process");
 
 // packages/kong-cli/src/common/extensionContract.ts
 var import__ = __toESM(require__());
@@ -63509,7 +62983,188 @@ function getExtensionContract(filePath) {
   return contract;
 }
 
+// packages/kong-cli/src/services/api.ts
+var import_keyring2 = __toESM(require_keyring());
+
+// node_modules/jwt-decode/build/esm/index.js
+var InvalidTokenError = class extends Error {
+};
+InvalidTokenError.prototype.name = "InvalidTokenError";
+function b64DecodeUnicode(str) {
+  return decodeURIComponent(atob(str).replace(/(.)/g, (m, p) => {
+    let code = p.charCodeAt(0).toString(16).toUpperCase();
+    if (code.length < 2) {
+      code = "0" + code;
+    }
+    return "%" + code;
+  }));
+}
+function base64UrlDecode(str) {
+  let output = str.replace(/-/g, "+").replace(/_/g, "/");
+  switch (output.length % 4) {
+    case 0:
+      break;
+    case 2:
+      output += "==";
+      break;
+    case 3:
+      output += "=";
+      break;
+    default:
+      throw new Error("base64 string is not of the correct length");
+  }
+  try {
+    return b64DecodeUnicode(output);
+  } catch (err) {
+    return atob(output);
+  }
+}
+function jwtDecode(token, options) {
+  if (typeof token !== "string") {
+    throw new InvalidTokenError("Invalid token specified: must be a string");
+  }
+  options || (options = {});
+  const pos = options.header === true ? 0 : 1;
+  const part = token.split(".")[pos];
+  if (typeof part !== "string") {
+    throw new InvalidTokenError(`Invalid token specified: missing part #${pos + 1}`);
+  }
+  let decoded;
+  try {
+    decoded = base64UrlDecode(part);
+  } catch (e) {
+    throw new InvalidTokenError(`Invalid token specified: invalid base64 for part #${pos + 1} (${e.message})`);
+  }
+  try {
+    return JSON.parse(decoded);
+  } catch (e) {
+    throw new InvalidTokenError(`Invalid token specified: invalid json for part #${pos + 1} (${e.message})`);
+  }
+}
+
+// packages/kong-cli/src/services/api.ts
+function requestConfigProvider(profile) {
+  const cached = {
+    headers: {
+      "Content-Type": "application/json",
+      "X-App-Tenant": parseTenant(profile.kongBaseUrl)
+    }
+  };
+  return async () => {
+    if (cached.headers?.Authorization) {
+      try {
+        const auth = cached.headers.Authorization;
+        const accessToken = auth.split("Bearer ")[1]?.trim();
+        if (accessToken) {
+          const decoded = jwtDecode(accessToken);
+          if (decoded.exp !== void 0) {
+            const nowSeconds = Date.now() / 1e3;
+            if (decoded.exp > nowSeconds + 60) {
+              return cached;
+            }
+          }
+        }
+      } catch (ex) {
+        console.warn("failed to use cached token, fetching new one", ex);
+      }
+    }
+    const url2 = joinUrlAndPath(
+      profile.kongBaseUrl,
+      "api/keycloak/realms/kong/protocol/openid-connect/token"
+    );
+    const entry = new import_keyring2.Entry(profile.kongBaseUrl, profile.userName);
+    const password = entry.getPassword();
+    if (!password) {
+      throw new Error("No password found in keyring for user: " + profile.userName);
+    }
+    const params = new URLSearchParams({
+      grant_type: "password",
+      client_id: "kong-web",
+      username: profile.userName,
+      password
+    });
+    const response = await axios_default.post(url2, params, {
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      }
+    });
+    cached.headers = {
+      ...cached.headers,
+      ["Authorization"]: `Bearer ${response.data.access_token}`
+    };
+    return cached;
+  };
+}
+
+// packages/kong-cli/src/services/managementClient.ts
+var ManagementClient = class {
+  constructor(kongBaseUrl, requestConfigProvider2) {
+    this.requestConfigProvider = requestConfigProvider2;
+    this.baseUrl = joinUrlAndPath(kongBaseUrl, "/api/management");
+  }
+  async updateExtension(extension) {
+    const url2 = joinUrlAndPath(this.baseUrl, "v1/extensions");
+    await axios_default.put(url2, extension, await this.requestConfigProvider());
+  }
+  async createExtensionSnapshot(extensionId, snapshot) {
+    const url2 = joinUrlAndPath(this.baseUrl, "v1/extensions", extensionId, "snapshots");
+    await axios_default.post(url2, snapshot, await this.requestConfigProvider());
+  }
+  async getExtensionSnapshot(extensionId, extensionSnapshotVersion) {
+    const url2 = joinUrlAndPath(
+      this.baseUrl,
+      "v1/extensions",
+      extensionId,
+      "snapshots",
+      extensionSnapshotVersion
+    );
+    return (await axios_default.get(url2, await this.requestConfigProvider())).data;
+  }
+  async getExtensionSnapshotVersions(extensionId) {
+    const url2 = joinUrlAndPath(this.baseUrl, "v1/extensions", extensionId, "/snapshots/versions");
+    return (await axios_default.get(url2, await this.requestConfigProvider())).data;
+  }
+  async getExtensionSnapshotAliases(extensionId) {
+    const url2 = joinUrlAndPath(this.baseUrl, "v1/extensions", extensionId, "/aliases");
+    return (await axios_default.get(url2, await this.requestConfigProvider())).data;
+  }
+  async getDocumentSnapshotVersions(documentId) {
+    const url2 = joinUrlAndPath(this.baseUrl, "v1/documents", documentId, "/snapshots/versions");
+    return (await axios_default.get(url2, await this.requestConfigProvider())).data;
+  }
+  async getProcessAliases(documentId) {
+    const url2 = joinUrlAndPath(this.baseUrl, "v1/processes", documentId, "/aliases");
+    return (await axios_default.get(url2, await this.requestConfigProvider())).data;
+  }
+  async getAuditLog(objectType2, objectId, createdAfter) {
+    const url2 = joinUrlAndPath(this.baseUrl, "v1/audit");
+    const config = await this.requestConfigProvider();
+    const response = await axios_default.get(url2, {
+      ...config,
+      params: { ...config.params, objectType: objectType2, objectId, createdAfter }
+    });
+    return response.data;
+  }
+};
+
+// packages/kong-cli/src/services/registryClient.ts
+var RegistryClient = class {
+  constructor(kongBaseUrl, requestConfigProvider2) {
+    this.requestConfigProvider = requestConfigProvider2;
+    this.baseUrl = joinUrlAndPath(kongBaseUrl, "/api/registry");
+  }
+  async getPublishDetails(appName) {
+    const url2 = joinUrlAndPath(this.baseUrl, "v1/repository", appName, "publish/details");
+    return (await axios_default.post(url2, {}, await this.requestConfigProvider())).data;
+  }
+};
+
 // packages/kong-cli/src/commands/publishVersionCommand.ts
+function extractJsonObject(text) {
+  const start = text.indexOf("{");
+  const end = text.lastIndexOf("}");
+  return start >= 0 && end > start ? text.slice(start, end + 1) : text;
+}
 var PublishVersionCommand = class {
   constructor(profile, verbose = false, contractPath = null) {
     this.profile = profile;
@@ -63523,14 +63178,36 @@ var PublishVersionCommand = class {
     const clientRequestConfigProvider = requestConfigProvider(profile);
     this.registryClient = new RegistryClient(profile.kongBaseUrl, clientRequestConfigProvider);
     this.managementClient = new ManagementClient(profile.kongBaseUrl, clientRequestConfigProvider);
-    const dockerVersion = (0, import_child_process3.spawnSync)("docker", ["--version"]);
+    const dockerVersion = (0, import_child_process2.spawnSync)("docker", ["--version"]);
     this.hasDocker = !dockerVersion.error;
   }
   get wslPrefix() {
     return this.isWin && !this.hasDocker ? "wsl" : "";
   }
-  async execute(appName, notes) {
-    await new Listr([...this.flowFactory(appName, notes)], {
+  // returns the published version number. `onStep` mirrors each task's
+  // lifecycle so an embedding command (e.g. kong connect) can surface the same
+  // progress without parsing the Listr output.
+  async execute(appName, notes, onStep) {
+    const tasks = [...this.flowFactory(appName, notes)].map(
+      (definition) => {
+        const title = String(definition.title);
+        const original = definition.task;
+        return {
+          ...definition,
+          task: async (ctx2, task) => {
+            onStep?.(title, "pending");
+            try {
+              await original?.(ctx2, task);
+              onStep?.(title, "succeeded");
+            } catch (ex) {
+              onStep?.(title, "failed");
+              throw ex;
+            }
+          }
+        };
+      }
+    );
+    const ctx = await new Listr(tasks, {
       renderer: "default",
       rendererOptions: {
         logger: new ListrLogger({
@@ -63538,6 +63215,7 @@ var PublishVersionCommand = class {
         })
       }
     }).run();
+    return Number(ctx.publishDetails?.imageVersion ?? NaN);
   }
   *flowFactory(appName, notes) {
     const kongJson = getKongJson();
@@ -63563,7 +63241,8 @@ var PublishVersionCommand = class {
         } else {
           const isPythonSdk = kongJson.sdk === "python";
           const cmdText = isPythonSdk ? this.getPythonSchemaCmdText() : this.getKotlinSchemaCmdTask();
-          ctx.contractText = await spawnCommand(cmdText, logger, !isPythonSdk);
+          const raw = await spawnCommand(cmdText, logger, !isPythonSdk);
+          ctx.contractText = isPythonSdk ? extractJsonObject(raw) : raw;
         }
       },
       rendererOptions: this.defaultRendererOptions
@@ -63602,7 +63281,7 @@ var PublishVersionCommand = class {
     yield {
       title: "docker push",
       task: async (ctx, task) => {
-        const cmd = this.dockerPushCmdText(ctx.fullImageName);
+        const cmd = this.dockerPushCmdText(notNull(ctx.fullImageName));
         await spawnCommand(
           cmd,
           new ListrTaskLogger(task, this.verbose ? 3 /* DEBUG */ : 0 /* INFO */)
@@ -63713,6 +63392,412 @@ var PublishVersionCommand = class {
   }
 };
 
+// packages/kong-cli/src/commands/connectCommand.ts
+var ansi = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  cyan: "\x1B[36m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m"
+};
+var DEPLOY_STEPS = [
+  "install dependencies",
+  "generate schema",
+  "get publish details",
+  "docker login",
+  "docker build",
+  "docker push",
+  "save publish details"
+];
+var ConnectCommand = class {
+  constructor(profileName, profile) {
+    this.profileName = profileName;
+    this.profile = profile;
+    this.isWin = process.platform === "win32";
+    this.deployments = /* @__PURE__ */ new Map();
+    // one scaffolded template per extension id, reused across requests so we do
+    // not pay the `kong generate` cost on every test/deploy of the same extension
+    this.templates = /* @__PURE__ */ new Map();
+    // project operations chdir into a temp workspace, so they must not overlap
+    this.lock = Promise.resolve();
+  }
+  async execute() {
+    const server = import_http4.default.createServer((request, response) => {
+      this.handle(request, response).catch((ex) => {
+        console.error("request failed", ex);
+        if (!response.headersSent) {
+          this.json(response, 500, { error: String(ex) });
+        }
+      });
+    });
+    const cleanup = () => this.cleanupTemplates();
+    process.on("exit", cleanup);
+    process.on("SIGINT", () => process.exit(0));
+    process.on("SIGTERM", () => process.exit(0));
+    server.listen(APP_CONNECT_PORT, () => {
+      const { bold, dim, cyan, green, yellow, reset } = ansi;
+      console.info();
+      console.info(`${green}${bold}\u2714 kong connect is ready${reset}`);
+      console.info(
+        `${dim}  profile ${reset}${cyan}${this.profileName}${reset}${dim}  \xB7  ${reset}${cyan}${this.profile.kongBaseUrl}${reset}`
+      );
+      console.info(`${dim}  listening on ${reset}${cyan}http://localhost:${APP_CONNECT_PORT}${reset}`);
+      console.info();
+      console.info(
+        `${yellow}\u279C${reset} ${bold}keep this terminal open${reset} ${dim}while working in the kong ui  \xB7  ctrl+c to stop${reset}`
+      );
+      console.info();
+    });
+  }
+  async handle(request, response) {
+    response.setHeader("Access-Control-Allow-Origin", "*");
+    response.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    response.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    if (request.method === "OPTIONS") {
+      response.writeHead(204);
+      response.end();
+      return;
+    }
+    const url2 = new URL(request.url ?? "/", `http://localhost:${APP_CONNECT_PORT}`);
+    if (request.method === "GET" && url2.pathname === "/v1/profile") {
+      this.json(response, 200, this.profileInfo());
+      return;
+    }
+    if (request.method === "POST" && url2.pathname === "/v1/tests") {
+      const body = await this.readBody(request);
+      this.json(response, 200, await this.runTests(body));
+      return;
+    }
+    if (request.method === "POST" && url2.pathname === "/v1/deployments") {
+      const body = await this.readBody(request);
+      this.json(response, 200, this.startDeployment(body));
+      return;
+    }
+    const statusMatch = url2.pathname.match(/^\/v1\/deployments\/([A-Za-z0-9-]+)$/);
+    if (request.method === "GET" && statusMatch) {
+      const job = this.deployments.get(statusMatch[1]);
+      if (!job) {
+        this.json(response, 404, { error: `unknown deployment ${statusMatch[1]}` });
+        return;
+      }
+      this.json(response, 200, job);
+      return;
+    }
+    this.json(response, 404, { error: `unknown route ${request.method} ${url2.pathname}` });
+  }
+  profileInfo() {
+    return {
+      profile: this.profileName,
+      baseUrl: this.profile.kongBaseUrl,
+      userName: this.profile.userName,
+      docker: !(0, import_child_process3.spawnSync)("docker", ["--version"]).error,
+      python: !(0, import_child_process3.spawnSync)(this.pythonBin(), ["--version"]).error
+    };
+  }
+  /** Scaffolds the template, installs its deps and runs src/main_test.py. */
+  async runTests(request) {
+    return this.runExclusive(async () => {
+      console.info(`
+${ansi.cyan}\u25B6 running tests for ${request.extensionName}${ansi.reset}`);
+      const { projectRoot } = await this.prepareTemplate(
+        request.files,
+        request.extensionId,
+        request.extensionName
+      );
+      const previousCwd = process.cwd();
+      try {
+        process.chdir(projectRoot);
+        await new InstallCommand(true).execute(projectRoot);
+        const result = await this.run(
+          this.venvPython(projectRoot),
+          ["-m", "pytest", import_path6.default.join("src", "main_test.py"), "-v"],
+          projectRoot
+        );
+        return { passed: result.exitCode === 0, output: extractTestReport(result.output) };
+      } finally {
+        process.chdir(previousCwd);
+      }
+    });
+  }
+  /**
+   * Deployments are asynchronous: the ui polls GET /v1/deployments/{id} and
+   * renders the steps in the same progress dialog as the kong-build path.
+   */
+  startDeployment(request) {
+    const deploymentId = generateShortId2();
+    const job = {
+      status: "pending",
+      steps: DEPLOY_STEPS.map((name) => ({ name, status: "idle" })),
+      output: ""
+    };
+    this.deployments.set(deploymentId, job);
+    this.deploy(request, job).catch((ex) => {
+      job.status = "failed";
+      job.error = ex.message;
+      for (const step of job.steps) {
+        if (step.status === "pending") {
+          step.status = "failed";
+        }
+      }
+    });
+    return { deploymentId };
+  }
+  /**
+   * Scaffolds the cli template, swaps in the bundle and reuses kong install +
+   * kong publish-version (docker build/push + schema + snapshot save), mirroring
+   * their progress into the deployment status the ui polls.
+   */
+  async deploy(request, job) {
+    await this.runExclusive(async () => {
+      console.info(`
+${ansi.cyan}\u25B6 deploying ${request.extensionName}${ansi.reset}`);
+      const tenant = parseTenant(this.profile.kongBaseUrl);
+      const { projectRoot } = await this.prepareTemplate(
+        request.files,
+        request.extensionId,
+        request.extensionName
+      );
+      const previousCwd = process.cwd();
+      try {
+        this.setStep(job, "install dependencies", "pending");
+        process.chdir(projectRoot);
+        await new InstallCommand(true).execute(projectRoot);
+        this.setStep(job, "install dependencies", "succeeded");
+        const version = await new PublishVersionCommand(this.profile, true).execute(
+          `${tenant}-k-extension-${request.extensionId}`,
+          request.notes ?? "",
+          (step, status) => this.setStep(job, step, status)
+        );
+        job.version = version;
+        job.status = "succeeded";
+        job.output = `${job.output}the version ${version} has been successfully published!
+`;
+      } finally {
+        process.chdir(previousCwd);
+      }
+    });
+  }
+  /**
+   * Returns the (cached) scaffolded template for the extension, generating it
+   * once with `kong generate` and only swapping in the ui bundle's src folder
+   * and requirements.txt on subsequent calls. kong.json is patched so the
+   * publish saves the snapshot under the real extension.
+   */
+  async prepareTemplate(files, extensionId, extensionName) {
+    const template2 = this.templates.get(extensionId) ?? await this.scaffold(extensionName);
+    this.templates.set(extensionId, template2);
+    const { projectRoot } = template2;
+    import_fs5.default.rmSync(import_path6.default.join(projectRoot, "src"), { recursive: true, force: true });
+    for (const file of files) {
+      const target = import_path6.default.resolve(projectRoot, file.name);
+      if (!target.startsWith(projectRoot)) {
+        continue;
+      }
+      import_fs5.default.mkdirSync(import_path6.default.dirname(target), { recursive: true });
+      import_fs5.default.writeFileSync(
+        target,
+        file.binary === true ? Buffer.from(file.content, "base64") : file.content
+      );
+    }
+    const kongJsonPath = import_path6.default.join(projectRoot, "kong.json");
+    if (import_fs5.default.existsSync(kongJsonPath)) {
+      const kongJson = JSON.parse(import_fs5.default.readFileSync(kongJsonPath, "utf-8"));
+      kongJson.id = extensionId;
+      kongJson.name = extensionName;
+      import_fs5.default.writeFileSync(kongJsonPath, JSON.stringify(kongJson, null, 2));
+    }
+    return template2;
+  }
+  /** Runs `kong generate` into a fresh temp workspace and locates its root. */
+  async scaffold(extensionName) {
+    const parent = import_fs5.default.mkdtempSync(import_path6.default.join(import_os3.default.tmpdir(), `kong-connect-${generateShortId2()}-`));
+    const previousCwd = process.cwd();
+    try {
+      process.chdir(parent);
+      await new GenerateCommand().execute(extensionName, "python", getPresetVersion(), "basic");
+    } finally {
+      process.chdir(previousCwd);
+    }
+    const scaffold = import_fs5.default.readdirSync(parent, { withFileTypes: true }).find((entry) => entry.isDirectory());
+    if (!scaffold) {
+      throw new Error("kong generate did not produce a project");
+    }
+    return { parent, projectRoot: import_path6.default.join(parent, scaffold.name) };
+  }
+  cleanupTemplates() {
+    for (const { parent } of this.templates.values()) {
+      import_fs5.default.rmSync(parent, { recursive: true, force: true });
+    }
+    this.templates.clear();
+  }
+  setStep(job, name, status) {
+    const step = job.steps.find((item) => item.name === name);
+    if (step) {
+      step.status = status;
+    }
+    job.output = `${job.output}${name}: ${status}
+`;
+  }
+  runExclusive(action) {
+    const result = this.lock.then(action, action);
+    this.lock = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
+  }
+  pythonBin() {
+    return (0, import_child_process3.spawnSync)("python", ["--version"]).error ? "python3" : "python";
+  }
+  venvPython(workDir) {
+    return this.isWin ? import_path6.default.join(workDir, ".venv", "Scripts", "python.exe") : import_path6.default.join(workDir, ".venv", "bin", "python");
+  }
+  // runs a child process, echoing its output to this terminal (so the operator
+  // sees what is going on) while also capturing it for the ui response
+  run(command, args, cwd, stdin) {
+    return new Promise((resolve2) => {
+      const child = (0, import_child_process3.spawn)(command, args, { cwd });
+      const chunks = [];
+      child.stdout.on("data", (data) => {
+        chunks.push(String(data));
+        process.stdout.write(data);
+      });
+      child.stderr.on("data", (data) => {
+        chunks.push(String(data));
+        process.stderr.write(data);
+      });
+      child.on("error", (error) => resolve2({ exitCode: -1, output: String(error) }));
+      child.on("close", (exitCode) => resolve2({ exitCode: exitCode ?? -1, output: chunks.join("") }));
+      if (stdin !== void 0) {
+        child.stdin.write(stdin);
+      }
+      child.stdin.end();
+    });
+  }
+  readBody(request) {
+    return new Promise((resolve2, reject) => {
+      const chunks = [];
+      request.on("data", (chunk) => chunks.push(chunk));
+      request.on("error", reject);
+      request.on("end", () => {
+        try {
+          resolve2(JSON.parse(Buffer.concat(chunks).toString("utf-8") || "{}"));
+        } catch (ex) {
+          reject(ex instanceof Error ? ex : new Error(String(ex)));
+        }
+      });
+    });
+  }
+  json(response, status, body) {
+    response.writeHead(status, { "Content-Type": "application/json" });
+    response.end(JSON.stringify(body));
+  }
+};
+function extractTestReport(output) {
+  const marker = output.indexOf("test session starts");
+  if (marker < 0) {
+    return output.trim();
+  }
+  const lineStart = output.lastIndexOf("\n", marker);
+  return output.slice(lineStart < 0 ? 0 : lineStart + 1).trim();
+}
+
+// packages/kong-cli/src/commands/listAliasesCommand.ts
+var ListAliasesCommand = class {
+  constructor(profile, verbose) {
+    this.profile = profile;
+    this.verbose = verbose;
+    this.managementClient = new ManagementClient(
+      this.profile.kongBaseUrl,
+      requestConfigProvider(profile)
+    );
+  }
+  async execute(processId) {
+    await new Listr(
+      [
+        {
+          title: processId ? `list process aliases (${processId})` : "list extension aliases",
+          task: async (ctx, task) => {
+            const aliases = processId ? await this.managementClient.getProcessAliases(processId) : await this.managementClient.getExtensionSnapshotAliases(getKongJson().id);
+            if (aliases.length === 0) {
+              task.output = "no aliases available";
+            } else {
+              const result = [];
+              for (const alias of aliases) {
+                for (const item of alias.use) {
+                  result.push(
+                    `${alias.name}, ${item.snapshot.version}, ${item.balance ? `${item.balance}%` : "shadow"}`
+                  );
+                }
+              }
+              task.output = result.join("\n");
+            }
+          },
+          rendererOptions: {
+            persistentOutput: true
+          }
+        }
+      ],
+      {
+        renderer: "default",
+        rendererOptions: {
+          logger: new ListrLogger({
+            processOutput: new ProcessOutput(process.stderr, process.stderr)
+          })
+        }
+      }
+    ).run();
+  }
+};
+
+// packages/kong-cli/src/commands/listVersionsCommand.ts
+var ListVersionsCommand = class {
+  constructor(profile, verbose) {
+    this.verbose = verbose;
+    this.managementClient = new ManagementClient(
+      profile.kongBaseUrl,
+      requestConfigProvider(profile)
+    );
+  }
+  async execute(processId) {
+    await new Listr(
+      [
+        {
+          title: processId ? `list process snapshot versions (${processId})` : "list extension snapshot versions",
+          task: async (ctx, task) => {
+            const versions = processId ? await this.managementClient.getDocumentSnapshotVersions(
+              processId
+            ) : await this.managementClient.getExtensionSnapshotVersions(getKongJson().id);
+            if (versions.length === 0) {
+              task.output = "no versions available";
+            } else {
+              const result = [];
+              for (const ver of versions) {
+                result.push(
+                  `${ver.version}, ${ver.created}, ${ver.createdBy}, ${ver.notes || "no notes"}`
+                );
+              }
+              task.output = result.join("\n");
+            }
+          },
+          rendererOptions: {
+            persistentOutput: true
+          }
+        }
+      ],
+      {
+        renderer: "default",
+        rendererOptions: {
+          logger: new ListrLogger({
+            processOutput: new ProcessOutput(process.stderr, process.stderr)
+          })
+        }
+      }
+    ).run();
+  }
+};
+
 // packages/kong-cli/src/common/deployment.ts
 var DEPLOY_SUCCESS_ACTIONS = /* @__PURE__ */ new Set(["deployment completed"]);
 var DEPLOY_FAILURE_ACTIONS = /* @__PURE__ */ new Set(["deployment failed"]);
@@ -63860,13 +63945,13 @@ function parseVersionWeightList(list) {
   }
   return uses;
 }
-var DEPLOY_STEPS = [
+var DEPLOY_STEPS2 = [
   "create deployment",
   "save deployment details",
   "deployment completed"
 ];
 function createDeploySteps() {
-  return DEPLOY_STEPS.map((action) => {
+  return DEPLOY_STEPS2.map((action) => {
     const handlers = {
       resolve: () => void 0,
       reject: () => void 0
@@ -63999,17 +64084,6 @@ var SetAliasCommand = class {
   }
 };
 
-// packages/kong-cli/src/common/cli.ts
-var import_fs5 = __toESM(require("fs"));
-var import_path6 = __toESM(require("path"));
-function getPresetVersion() {
-  const packageJsonPath = import_path6.default.join(__dirname, "package.json");
-  if (!import_fs5.default.existsSync(packageJsonPath)) {
-    throw new AppError(`package.json file was not found at path: ${packageJsonPath}`);
-  }
-  return require(packageJsonPath).version;
-}
-
 // packages/kong-cli/src/index.ts
 import_dotenv_expand.default.expand(import_dotenv.default.config({ path: import_path7.default.join(__dirname, ".env"), quiet: true }));
 async function main() {