@devkong/cli 0.0.67-alpha.27 → 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,1610 +60902,1092 @@ 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})`);
+    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/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
+// packages/kong-cli/src/commands/generateCommand.ts
+var GenerateCommand = class {
+  async execute(extensionName, sdk, presetVersion, template2) {
+    const id = generateShortId2();
+    const variant = sdk === "python" ? template2 ?? await this.promptTemplate() : "basic";
+    validateKongJson({
+      id,
+      sdk,
+      name: extensionName,
+      category: "unknown",
+      settings: {}
     });
-    const response = await axios_default.post(url2, params, {
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded"
-      }
+    await (0, import_create_nx_workspace.createWorkspace)(`@devkong/cli-nx@${presetVersion}`, {
+      name: extensionName,
+      id,
+      platform: sdk,
+      // Passed through to the preset generator. Not named `template` on purpose:
+      // create-nx-workspace reserves that option for cloning a GitHub workspace.
+      variant,
+      nxCloud: "skip",
+      packageManager: "npm",
+      trustThirdPartyPreset: true,
+      analytics: false
     });
-    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 }
+  async promptTemplate() {
+    const { template: template2 } = await dist_default14.prompt({
+      type: "select",
+      name: "template",
+      message: "which template would you like to use?",
+      default: "basic",
+      choices: [
+        { name: "basic - a single operation", value: "basic" },
+        {
+          name: "with-secret - multiple operations with a secret example",
+          value: "with-secret"
+        },
+        {
+          name: "with-s3 - download a file from S3 using an s3 secret",
+          value: "with-s3"
+        }
+      ]
     });
-    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;
+    return template2;
   }
 };
 
-// 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
+// node_modules/listr2/node_modules/eventemitter3/index.mjs
+var import_index = __toESM(require_eventemitter3(), 1);
+var eventemitter3_default = import_index.default;
 
-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 DEPLOY_STEPS = [
-  "install dependencies",
-  "generate schema",
-  "get publish details",
-  "docker login",
-  "docker build",
-  "docker push",
-  "save publish details"
-];
-function notNullStep(job, name) {
-  const step = job.steps.find((item) => item.name === name);
-  if (!step) {
-    throw new Error(`unknown deployment step ${name}`);
-  }
-  return step;
-}
-var ConnectCommand = class {
-  constructor(profileName, profile) {
-    this.profileName = profileName;
-    this.profile = profile;
-    this.isWin = process.platform === "win32";
-    this.deployments = /* @__PURE__ */ new Map();
-    const provider = requestConfigProvider(profile);
-    this.registryClient = new RegistryClient(profile.kongBaseUrl, provider);
-    this.managementClient = new ManagementClient(profile.kongBaseUrl, provider);
+// node_modules/listr2/dist/index.mjs
+var import_node_util11 = require("node:util");
+var import_util4 = require("util");
+var import_os2 = require("os");
+var import_string_decoder = require("string_decoder");
+var import_stream5 = require("stream");
+var import_rfdc = __toESM(require_rfdc(), 1);
+var import_crypto2 = require("crypto");
+var ANSI_ESCAPE_CODES = {
+  CURSOR_HIDE: "\x1B[?25l",
+  CURSOR_SHOW: "\x1B[?25h"
+};
+var ListrTaskState = /* @__PURE__ */ (function(ListrTaskState2) {
+  ListrTaskState2["WAITING"] = "WAITING";
+  ListrTaskState2["STARTED"] = "STARTED";
+  ListrTaskState2["COMPLETED"] = "COMPLETED";
+  ListrTaskState2["FAILED"] = "FAILED";
+  ListrTaskState2["SKIPPED"] = "SKIPPED";
+  ListrTaskState2["ROLLING_BACK"] = "ROLLING_BACK";
+  ListrTaskState2["ROLLED_BACK"] = "ROLLED_BACK";
+  ListrTaskState2["RETRY"] = "RETRY";
+  ListrTaskState2["PAUSED"] = "PAUSED";
+  ListrTaskState2["PROMPT"] = "PROMPT";
+  ListrTaskState2["PROMPT_COMPLETED"] = "PROMPT_COMPLETED";
+  ListrTaskState2["PROMPT_FAILED"] = "PROMPT_FAILED";
+  return ListrTaskState2;
+})({});
+var EventManager = class {
+  emitter = new eventemitter3_default();
+  emit(dispatch, args) {
+    this.emitter.emit(dispatch, args);
   }
-  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");
-    });
+  on(dispatch, handler) {
+    this.emitter.addListener(dispatch, handler);
   }
-  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, 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}` });
+  once(dispatch, handler) {
+    this.emitter.once(dispatch, handler);
   }
-  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
-    };
+  off(dispatch, handler) {
+    this.emitter.off(dispatch, handler);
   }
-  /** 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 });
-    }
+  complete() {
+    this.emitter.removeAllListeners();
   }
-  /**
-   * 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 = generateShortId();
-    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 };
+};
+function isObservable(obj) {
+  return !!obj && typeof obj === "object" && typeof obj.subscribe === "function";
+}
+function isReadable(obj) {
+  return !!obj && typeof obj === "object" && obj.readable === true && typeof obj.read === "function" && typeof obj.on === "function";
+}
+function isUnicodeSupported2() {
+  return !!process.env["LISTR_FORCE_UNICODE"] || process.platform !== "win32" || !!process.env.CI || !!process.env.WT_SESSION || process.env.TERM_PROGRAM === "vscode" || process.env.TERM === "xterm-256color" || process.env.TERM === "alacritty";
+}
+var CLEAR_LINE_REGEX = "(?:\\u001b|\\u009b)\\[[\\=><~/#&.:=?%@~_-]*[0-9]*[\\a-ln-tqyz=><~/#&.:=?%@~_-]+";
+var BELL_REGEX = /\u0007/;
+function cleanseAnsi(chunk) {
+  return String(chunk).replace(new RegExp(CLEAR_LINE_REGEX, "gmi"), "").replace(new RegExp(BELL_REGEX, "gmi"), "").trim();
+}
+var color = Object.fromEntries(Object.keys(import_node_util11.inspect.colors).map((color2) => [color2, (text) => (0, import_node_util11.styleText)(color2, String(text))]));
+function indent(string, count) {
+  return string.replace(/^(?!\s*$)/gm, " ".repeat(count));
+}
+var FIGURES_MAIN = {
+  warning: "\u26A0",
+  cross: "\u2716",
+  arrowDown: "\u2193",
+  tick: "\u2714",
+  arrowRight: "\u2192",
+  pointer: "\u276F",
+  checkboxOn: "\u2612",
+  arrowLeft: "\u2190",
+  squareSmallFilled: "\u25FC",
+  pointerSmall: "\u203A"
+};
+var FIGURES_FALLBACK = {
+  ...FIGURES_MAIN,
+  warning: "\u203C",
+  cross: "\xD7",
+  tick: "\u221A",
+  pointer: ">",
+  checkboxOn: "[\xD7]",
+  squareSmallFilled: "\u25A0"
+};
+var figures2 = isUnicodeSupported2() ? FIGURES_MAIN : FIGURES_FALLBACK;
+function splat(message2, ...splat2) {
+  return (0, import_util4.format)(String(message2), ...splat2);
+}
+var LISTR_LOGGER_STYLE = {
+  icon: {
+    ["STARTED"]: figures2.pointer,
+    ["FAILED"]: figures2.cross,
+    ["SKIPPED"]: figures2.arrowDown,
+    ["COMPLETED"]: figures2.tick,
+    ["OUTPUT"]: figures2.pointerSmall,
+    ["TITLE"]: figures2.arrowRight,
+    ["RETRY"]: figures2.warning,
+    ["ROLLBACK"]: figures2.arrowLeft,
+    ["PAUSED"]: figures2.squareSmallFilled
+  },
+  color: {
+    ["STARTED"]: color.yellow,
+    ["FAILED"]: color.red,
+    ["SKIPPED"]: color.yellow,
+    ["COMPLETED"]: color.green,
+    ["RETRY"]: color.yellowBright,
+    ["ROLLBACK"]: color.redBright,
+    ["PAUSED"]: color.yellowBright
   }
-  /**
-   * 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, job) {
-    const step = (name) => notNullStep(job, name);
-    const runStep = async (name, action) => {
-      step(name).status = "pending";
-      try {
-        const result = await action();
-        step(name).status = "succeeded";
-        return result;
-      } catch (ex) {
-        step(name).status = "failed";
-        throw ex;
-      }
+};
+var LISTR_LOGGER_STDERR_LEVELS = [
+  "RETRY",
+  "ROLLBACK",
+  "FAILED"
+];
+var ListrLogger = class {
+  options;
+  process;
+  constructor(options) {
+    this.options = options;
+    this.options = {
+      useIcons: true,
+      toStderr: [],
+      ...options ?? {}
     };
-    const workDir = this.materialize(request.files);
-    try {
-      const log = [];
-      import_fs3.default.writeFileSync(import_path4.default.join(workDir, "Dockerfile"), DOCKERFILE);
-      await runStep("install dependencies", async () => {
-        const prepared = await this.prepareVenv(workDir, log);
-        job.output = log.join("\n");
-        if (prepared.exitCode !== 0) {
-          throw new Error(`dependency install failed:
-${log.join("\n")}`);
-        }
-      });
-      const contract = await runStep("generate schema", async () => {
-        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}`);
-        }
-        return JSON.parse(schema.output);
-      });
-      const publishDetails = await runStep("get publish details", () => {
-        const tenant = parseTenant(this.profile.kongBaseUrl);
-        return 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 dockerStep 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] }
-      ]) {
-        await runStep(dockerStep.title, async () => {
-          log.push(`> ${dockerStep.title}`);
-          const result = await this.run(
-            dockerStep.command,
-            dockerStep.args,
-            workDir,
-            dockerStep.stdin
-          );
-          log.push(result.output);
-          job.output = log.join("\n");
-          if (result.exitCode !== 0) {
-            throw new Error(`${dockerStep.title} failed:
-${result.output}`);
-          }
-        });
-      }
-      const version = Number(publishDetails.imageVersion);
-      await runStep(
-        "save publish details",
-        () => this.managementClient.createExtensionSnapshot(
-          request.extensionId,
-          this.snapshotFor(request, version, contract)
-        )
-      );
-      log.push(`the version ${version} has been successfully published!`);
-      job.output = log.join("\n");
-      job.version = version;
-      job.status = "succeeded";
-    } finally {
-      import_fs3.default.rmSync(workDir, { recursive: true, force: true });
-    }
+    this.options.fields ??= {};
+    this.options.fields.prefix ??= [];
+    this.options.fields.suffix ??= [];
+    this.process = this.options.processOutput ?? new ProcessOutput();
   }
-  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
-      );
+  log(level, message2, options) {
+    const output = this.format(level, message2, options);
+    if (this.options.toStderr.includes(level)) {
+      this.process.toStderr(output);
+      return;
     }
-    import_fs3.default.writeFileSync(import_path4.default.join(workDir, "pyproject.toml"), PYPROJECT);
-    return workDir;
+    this.process.toStdout(output);
   }
-  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;
+  toStdout(message2, options, eol = true) {
+    this.process.toStdout(this.format(null, message2, options), eol);
   }
-  pythonBin() {
-    return (0, import_child_process2.spawnSync)("python", ["--version"]).error ? "python3" : "python";
+  toStderr(message2, options, eol = true) {
+    this.process.toStderr(this.format(null, message2, options), eol);
   }
-  venvPython(workDir) {
-    return this.isWin ? import_path4.default.join(workDir, ".venv", "Scripts", "python.exe") : import_path4.default.join(workDir, ".venv", "bin", "python");
+  wrap(message2, options) {
+    if (!message2) return message2;
+    return this.applyFormat(`[${message2}]`, options);
   }
-  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);
+  splat(...args) {
+    const message2 = args.shift() ?? "";
+    return args.length === 0 ? message2 : splat(message2, args);
+  }
+  suffix(message2, ...suffixes) {
+    suffixes.filter(Boolean).forEach((suffix) => {
+      message2 += this.spacing(message2);
+      if (typeof suffix === "string") message2 += this.wrap(suffix);
+      else if (typeof suffix === "object") {
+        suffix.args ??= [];
+        if (typeof suffix.condition === "function" ? !suffix.condition(...suffix.args) : !(suffix.condition ?? true)) return message2;
+        message2 += this.wrap(typeof suffix.field === "function" ? suffix.field(...suffix.args) : suffix.field, { format: suffix?.format(...suffix.args) });
       }
-      child.stdin.end();
     });
+    return message2;
   }
-  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)));
-        }
-      });
+  prefix(message2, ...prefixes) {
+    prefixes.filter(Boolean).forEach((prefix) => {
+      message2 = this.spacing(message2) + message2;
+      if (typeof prefix === "string") message2 = this.wrap(prefix) + message2;
+      else if (typeof prefix === "object") {
+        prefix.args ??= [];
+        if (typeof prefix.condition === "function" ? !prefix.condition(...prefix.args) : !(prefix.condition ?? true)) return message2;
+        message2 = this.wrap(typeof prefix.field === "function" ? prefix.field(...prefix.args) : prefix.field, { format: prefix?.format() }) + message2;
+      }
     });
+    return message2;
   }
-  json(response, status, body) {
-    response.writeHead(status, { "Content-Type": "application/json" });
-    response.end(JSON.stringify(body));
+  fields(message2, options) {
+    if (this.options?.fields?.prefix) message2 = this.prefix(message2, ...this.options.fields.prefix);
+    if (options?.prefix) message2 = this.prefix(message2, ...options.prefix);
+    if (options?.suffix) message2 = this.suffix(message2, ...options.suffix);
+    if (this.options?.fields?.suffix) message2 = this.suffix(message2, ...this.options.fields.suffix);
+    return message2;
+  }
+  icon(level, icon) {
+    if (!level) return null;
+    if (!icon) {
+      const i = this.options.icon?.[level];
+      icon = typeof i === "function" ? i() : i;
+    }
+    const coloring = this.options.color?.[level];
+    if (icon && coloring) icon = coloring(icon);
+    return icon;
+  }
+  format(level, message2, options) {
+    if (!Array.isArray(message2)) message2 = [message2];
+    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_os2.EOL);
+    return message2;
+  }
+  style(level, message2) {
+    if (!level || !message2) return message2;
+    const icon = this.icon(level, !this.options.useIcons && this.wrap(level));
+    if (icon) message2 = icon + " " + message2;
+    return message2;
+  }
+  applyFormat(message2, options) {
+    if (options?.format) return options.format(message2);
+    return message2;
+  }
+  spacing(message2) {
+    return typeof message2 === "undefined" || message2.trim() === "" ? "" : " ";
   }
 };
-
-// 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."
-    );
+var ProcessOutputBuffer = class {
+  options;
+  buffer = [];
+  decoder = new import_string_decoder.StringDecoder();
+  constructor(options) {
+    this.options = options;
   }
-  if (isEmpty(kongJson.category)) {
-    throw new AppError(
-      "The `category` field should not be empty. Please provide a category value in kong.json."
-    );
+  get all() {
+    return this.buffer;
   }
-  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"
-    );
+  get last() {
+    return this.buffer.at(-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.`
-    );
+  get length() {
+    return this.buffer.length;
   }
-  if (isEmpty(kongJson.name)) {
-    throw new AppError(
-      "The `name` field should not be empty. Please provide a valid name in kong.json."
-    );
+  write(data, ...args) {
+    const callback = args[args.length - 1];
+    this.buffer.push({
+      time: Date.now(),
+      stream: this.options?.stream,
+      entry: this.decoder.write(typeof data === "string" ? Buffer.from(data, typeof args[0] === "string" ? args[0] : void 0) : Buffer.from(data))
+    });
+    if (this.options?.limit) this.buffer = this.buffer.slice(-this.options.limit);
+    if (typeof callback === "function") callback();
+    return true;
   }
-  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."
-    );
+  reset() {
+    this.buffer = [];
   }
-  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 || [])
-    );
+};
+var ProcessOutputStream = class {
+  stream;
+  method;
+  buffer;
+  constructor(stream4) {
+    this.stream = stream4;
+    this.method = stream4.write;
+    this.buffer = new ProcessOutputBuffer({ stream: stream4 });
   }
-  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;
+  get out() {
+    const self2 = this;
+    return new Proxy(this.stream, { get(target, prop, receiver) {
+      if (prop === "write") return self2.write.bind(self2);
+      return Reflect.get(target, prop, receiver);
+    } });
   }
-}
-
-// packages/kong-cli/src/commands/generateCommand.ts
-var GenerateCommand = class {
-  async execute(extensionName, sdk, presetVersion, template2) {
-    const id = generateShortId();
-    const variant = sdk === "python" ? template2 ?? await this.promptTemplate() : "basic";
-    validateKongJson({
-      id,
-      sdk,
-      name: extensionName,
-      category: "unknown",
-      settings: {}
-    });
-    await (0, import_create_nx_workspace.createWorkspace)(`@devkong/cli-nx@${presetVersion}`, {
-      name: extensionName,
-      id,
-      platform: sdk,
-      // Passed through to the preset generator. Not named `template` on purpose:
-      // create-nx-workspace reserves that option for cloning a GitHub workspace.
-      variant,
-      nxCloud: "skip",
-      packageManager: "npm",
-      trustThirdPartyPreset: true,
-      analytics: false
-    });
+  hijack() {
+    this.stream.write = this.buffer.write.bind(this.buffer);
   }
-  async promptTemplate() {
-    const { template: template2 } = await dist_default14.prompt({
-      type: "select",
-      name: "template",
-      message: "which template would you like to use?",
-      default: "basic",
-      choices: [
-        { name: "basic - a single operation", value: "basic" },
-        {
-          name: "with-secret - multiple operations with a secret example",
-          value: "with-secret"
-        },
-        {
-          name: "with-s3 - download a file from S3 using an s3 secret",
-          value: "with-s3"
-        }
-      ]
-    });
-    return template2;
+  release() {
+    this.stream.write = this.method;
+    const buffer = [...this.buffer.all];
+    this.buffer.reset();
+    return buffer;
+  }
+  write(...args) {
+    return this.method.apply(this.stream, args);
   }
 };
-
-// node_modules/listr2/node_modules/eventemitter3/index.mjs
-var import_index = __toESM(require_eventemitter3(), 1);
-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_string_decoder = require("string_decoder");
-var import_stream5 = require("stream");
-var import_rfdc = __toESM(require_rfdc(), 1);
-var import_crypto2 = require("crypto");
-var ANSI_ESCAPE_CODES = {
-  CURSOR_HIDE: "\x1B[?25l",
-  CURSOR_SHOW: "\x1B[?25h"
-};
-var ListrTaskState = /* @__PURE__ */ (function(ListrTaskState2) {
-  ListrTaskState2["WAITING"] = "WAITING";
-  ListrTaskState2["STARTED"] = "STARTED";
-  ListrTaskState2["COMPLETED"] = "COMPLETED";
-  ListrTaskState2["FAILED"] = "FAILED";
-  ListrTaskState2["SKIPPED"] = "SKIPPED";
-  ListrTaskState2["ROLLING_BACK"] = "ROLLING_BACK";
-  ListrTaskState2["ROLLED_BACK"] = "ROLLED_BACK";
-  ListrTaskState2["RETRY"] = "RETRY";
-  ListrTaskState2["PAUSED"] = "PAUSED";
-  ListrTaskState2["PROMPT"] = "PROMPT";
-  ListrTaskState2["PROMPT_COMPLETED"] = "PROMPT_COMPLETED";
-  ListrTaskState2["PROMPT_FAILED"] = "PROMPT_FAILED";
-  return ListrTaskState2;
-})({});
-var EventManager = class {
-  emitter = new eventemitter3_default();
-  emit(dispatch, args) {
-    this.emitter.emit(dispatch, args);
+var ProcessOutput = class {
+  options;
+  stream;
+  active;
+  constructor(stdout, stderr, options) {
+    this.options = options;
+    this.stream = {
+      stdout: new ProcessOutputStream(stdout ?? process.stdout),
+      stderr: new ProcessOutputStream(stderr ?? process.stderr)
+    };
+    this.options = {
+      dump: ["stdout", "stderr"],
+      leaveEmptyLine: true,
+      ...options
+    };
   }
-  on(dispatch, handler) {
-    this.emitter.addListener(dispatch, handler);
+  get stdout() {
+    return this.stream.stdout.out;
   }
-  once(dispatch, handler) {
-    this.emitter.once(dispatch, handler);
+  get stderr() {
+    return this.stream.stderr.out;
   }
-  off(dispatch, handler) {
-    this.emitter.off(dispatch, handler);
+  hijack() {
+    if (this.active) throw new Error("ProcessOutput has been already hijacked!");
+    this.stream.stdout.write(ANSI_ESCAPE_CODES.CURSOR_HIDE);
+    Object.values(this.stream).forEach((stream4) => stream4.hijack());
+    this.active = true;
   }
-  complete() {
-    this.emitter.removeAllListeners();
+  release() {
+    const output = Object.entries(this.stream).map(([name, stream4]) => ({
+      name,
+      buffer: stream4.release()
+    })).filter((output2) => this.options.dump.includes(output2.name)).flatMap((output2) => output2.buffer).sort((a, b) => a.time - b.time).map((message2) => {
+      return {
+        ...message2,
+        entry: cleanseAnsi(message2.entry)
+      };
+    }).filter((message2) => message2.entry);
+    if (output.length > 0) {
+      if (this.options.leaveEmptyLine) this.stdout.write(import_os2.EOL);
+      output.forEach((message2) => {
+        (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_os2.EOL;
+    return this.stream.stdout.write(buffer);
+  }
+  toStderr(buffer, eol = true) {
+    if (eol) buffer = buffer + import_os2.EOL;
+    return this.stream.stderr.write(buffer);
   }
 };
-function isObservable(obj) {
-  return !!obj && typeof obj === "object" && typeof obj.subscribe === "function";
-}
-function isReadable(obj) {
-  return !!obj && typeof obj === "object" && obj.readable === true && typeof obj.read === "function" && typeof obj.on === "function";
-}
-function isUnicodeSupported2() {
-  return !!process.env["LISTR_FORCE_UNICODE"] || process.platform !== "win32" || !!process.env.CI || !!process.env.WT_SESSION || process.env.TERM_PROGRAM === "vscode" || process.env.TERM === "xterm-256color" || process.env.TERM === "alacritty";
-}
-var CLEAR_LINE_REGEX = "(?:\\u001b|\\u009b)\\[[\\=><~/#&.:=?%@~_-]*[0-9]*[\\a-ln-tqyz=><~/#&.:=?%@~_-]+";
-var BELL_REGEX = /\u0007/;
-function cleanseAnsi(chunk) {
-  return String(chunk).replace(new RegExp(CLEAR_LINE_REGEX, "gmi"), "").replace(new RegExp(BELL_REGEX, "gmi"), "").trim();
-}
-var color = Object.fromEntries(Object.keys(import_node_util11.inspect.colors).map((color2) => [color2, (text) => (0, import_node_util11.styleText)(color2, String(text))]));
-function indent(string, count) {
-  return string.replace(/^(?!\s*$)/gm, " ".repeat(count));
+function createWritable(cb) {
+  const writable = new import_stream5.Writable();
+  writable.rows = Infinity;
+  writable.columns = Infinity;
+  writable.write = (chunk) => {
+    cb(chunk.toString());
+    return true;
+  };
+  return writable;
 }
-var FIGURES_MAIN = {
-  warning: "\u26A0",
-  cross: "\u2716",
-  arrowDown: "\u2193",
-  tick: "\u2714",
-  arrowRight: "\u2192",
-  pointer: "\u276F",
-  checkboxOn: "\u2612",
-  arrowLeft: "\u2190",
-  squareSmallFilled: "\u25FC",
-  pointerSmall: "\u203A"
-};
-var FIGURES_FALLBACK = {
-  ...FIGURES_MAIN,
-  warning: "\u203C",
-  cross: "\xD7",
-  tick: "\u221A",
-  pointer: ">",
-  checkboxOn: "[\xD7]",
-  squareSmallFilled: "\u25A0"
+var Spinner = class {
+  spinner = !isUnicodeSupported2() ? [
+    "-",
+    "\\",
+    "|",
+    "/"
+  ] : [
+    "\u280B",
+    "\u2819",
+    "\u2839",
+    "\u2838",
+    "\u283C",
+    "\u2834",
+    "\u2826",
+    "\u2827",
+    "\u2807",
+    "\u280F"
+  ];
+  id;
+  spinnerPosition = 0;
+  spin() {
+    this.spinnerPosition = ++this.spinnerPosition % this.spinner.length;
+  }
+  fetch() {
+    return this.spinner[this.spinnerPosition];
+  }
+  isRunning() {
+    return !!this.id;
+  }
+  start(cb, interval = 100) {
+    this.id = setInterval(() => {
+      this.spin();
+      if (cb) cb();
+    }, interval);
+  }
+  stop() {
+    clearInterval(this.id);
+    this.id = void 0;
+  }
 };
-var figures2 = isUnicodeSupported2() ? FIGURES_MAIN : FIGURES_FALLBACK;
-function splat(message2, ...splat2) {
-  return (0, import_util4.format)(String(message2), ...splat2);
-}
-var LISTR_LOGGER_STYLE = {
+var LISTR_DEFAULT_RENDERER_STYLE = {
   icon: {
-    ["STARTED"]: figures2.pointer,
-    ["FAILED"]: figures2.cross,
-    ["SKIPPED"]: figures2.arrowDown,
-    ["COMPLETED"]: figures2.tick,
+    ["SKIPPED_WITH_COLLAPSE"]: figures2.arrowDown,
+    ["SKIPPED_WITHOUT_COLLAPSE"]: figures2.warning,
     ["OUTPUT"]: figures2.pointerSmall,
-    ["TITLE"]: figures2.arrowRight,
+    ["OUTPUT_WITH_BOTTOMBAR"]: figures2.pointerSmall,
+    ["PENDING"]: figures2.pointer,
+    ["COMPLETED"]: figures2.tick,
+    ["COMPLETED_WITH_FAILED_SUBTASKS"]: figures2.warning,
+    ["COMPLETED_WITH_SISTER_TASKS_FAILED"]: figures2.squareSmallFilled,
     ["RETRY"]: figures2.warning,
-    ["ROLLBACK"]: figures2.arrowLeft,
+    ["ROLLING_BACK"]: figures2.warning,
+    ["ROLLED_BACK"]: figures2.arrowLeft,
+    ["FAILED"]: figures2.cross,
+    ["FAILED_WITH_SUBTASKS"]: figures2.pointer,
+    ["WAITING"]: figures2.squareSmallFilled,
     ["PAUSED"]: figures2.squareSmallFilled
   },
   color: {
-    ["STARTED"]: color.yellow,
-    ["FAILED"]: color.red,
-    ["SKIPPED"]: color.yellow,
+    ["SKIPPED_WITH_COLLAPSE"]: color.yellow,
+    ["SKIPPED_WITHOUT_COLLAPSE"]: color.yellow,
+    ["PENDING"]: color.yellow,
     ["COMPLETED"]: color.green,
+    ["COMPLETED_WITH_FAILED_SUBTASKS"]: color.yellow,
+    ["COMPLETED_WITH_SISTER_TASKS_FAILED"]: color.red,
     ["RETRY"]: color.yellowBright,
-    ["ROLLBACK"]: color.redBright,
+    ["ROLLING_BACK"]: color.redBright,
+    ["ROLLED_BACK"]: color.redBright,
+    ["FAILED"]: color.red,
+    ["FAILED_WITH_SUBTASKS"]: color.red,
+    ["WAITING"]: color.dim,
     ["PAUSED"]: color.yellowBright
   }
 };
-var LISTR_LOGGER_STDERR_LEVELS = [
-  "RETRY",
-  "ROLLBACK",
-  "FAILED"
-];
-var ListrLogger = class {
+function parseTimer(duration) {
+  const seconds = Math.floor(duration / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  let parsedTime;
+  if (seconds === 0 && minutes === 0) parsedTime = `0.${Math.floor(duration / 100)}s`;
+  if (seconds > 0) parsedTime = `${seconds % 60}s`;
+  if (minutes > 0) parsedTime = `${minutes}m${parsedTime}`;
+  return parsedTime;
+}
+var PRESET_TIMER = {
+  condition: true,
+  field: parseTimer,
+  format: () => color.dim
+};
+var DefaultRenderer = class DefaultRenderer2 {
+  tasks;
   options;
-  process;
-  constructor(options) {
-    this.options = options;
-    this.options = {
-      useIcons: true,
-      toStderr: [],
-      ...options ?? {}
-    };
-    this.options.fields ??= {};
-    this.options.fields.prefix ??= [];
-    this.options.fields.suffix ??= [];
-    this.process = this.options.processOutput ?? new ProcessOutput();
-  }
-  log(level, message2, options) {
-    const output = this.format(level, message2, options);
-    if (this.options.toStderr.includes(level)) {
-      this.process.toStderr(output);
-      return;
+  events;
+  static nonTTY = false;
+  static rendererOptions = {
+    indentation: 2,
+    clearOutput: false,
+    showSubtasks: true,
+    collapseSubtasks: true,
+    collapseSkips: true,
+    showSkipMessage: true,
+    suffixSkips: false,
+    collapseErrors: true,
+    showErrorMessage: true,
+    suffixRetries: true,
+    lazy: false,
+    removeEmptyLines: true,
+    formatOutput: "wrap",
+    pausedTimer: {
+      ...PRESET_TIMER,
+      format: () => color.yellowBright
     }
-    this.process.toStdout(output);
-  }
-  toStdout(message2, options, eol = true) {
-    this.process.toStdout(this.format(null, message2, options), eol);
-  }
-  toStderr(message2, options, eol = true) {
-    this.process.toStderr(this.format(null, message2, options), eol);
-  }
-  wrap(message2, options) {
-    if (!message2) return message2;
-    return this.applyFormat(`[${message2}]`, options);
-  }
-  splat(...args) {
-    const message2 = args.shift() ?? "";
-    return args.length === 0 ? message2 : splat(message2, args);
-  }
-  suffix(message2, ...suffixes) {
-    suffixes.filter(Boolean).forEach((suffix) => {
-      message2 += this.spacing(message2);
-      if (typeof suffix === "string") message2 += this.wrap(suffix);
-      else if (typeof suffix === "object") {
-        suffix.args ??= [];
-        if (typeof suffix.condition === "function" ? !suffix.condition(...suffix.args) : !(suffix.condition ?? true)) return message2;
-        message2 += this.wrap(typeof suffix.field === "function" ? suffix.field(...suffix.args) : suffix.field, { format: suffix?.format(...suffix.args) });
+  };
+  static rendererTaskOptions = { outputBar: true };
+  prompt;
+  activePrompt;
+  spinner;
+  logger;
+  updater;
+  truncate;
+  wrap;
+  buffer = {
+    output: /* @__PURE__ */ new Map(),
+    bottom: /* @__PURE__ */ new Map()
+  };
+  cache = {
+    render: /* @__PURE__ */ new Map(),
+    rendererOptions: /* @__PURE__ */ new Map(),
+    rendererTaskOptions: /* @__PURE__ */ new Map()
+  };
+  constructor(tasks, options, events) {
+    this.tasks = tasks;
+    this.options = options;
+    this.events = events;
+    this.options = {
+      ...DefaultRenderer2.rendererOptions,
+      ...this.options,
+      icon: {
+        ...LISTR_DEFAULT_RENDERER_STYLE.icon,
+        ...options?.icon ?? {}
+      },
+      color: {
+        ...LISTR_DEFAULT_RENDERER_STYLE.color,
+        ...options?.color ?? {}
       }
+    };
+    this.spinner = this.options.spinner ?? new Spinner();
+    this.logger = this.options.logger ?? new ListrLogger({
+      useIcons: true,
+      toStderr: []
     });
-    return message2;
+    this.logger.options.icon = this.options.icon;
+    this.logger.options.color = this.options.color;
   }
-  prefix(message2, ...prefixes) {
-    prefixes.filter(Boolean).forEach((prefix) => {
-      message2 = this.spacing(message2) + message2;
-      if (typeof prefix === "string") message2 = this.wrap(prefix) + message2;
-      else if (typeof prefix === "object") {
-        prefix.args ??= [];
-        if (typeof prefix.condition === "function" ? !prefix.condition(...prefix.args) : !(prefix.condition ?? true)) return message2;
-        message2 = this.wrap(typeof prefix.field === "function" ? prefix.field(...prefix.args) : prefix.field, { format: prefix?.format() }) + message2;
-      }
+  async render() {
+    const { createLogUpdate: createLogUpdate2 } = await Promise.resolve().then(() => (init_log_update(), log_update_exports));
+    const { default: truncate } = await Promise.resolve().then(() => (init_cli_truncate(), cli_truncate_exports));
+    const { default: wrap } = await Promise.resolve().then(() => (init_wrap_ansi2(), wrap_ansi_exports));
+    this.updater = createLogUpdate2(this.logger.process.stdout);
+    this.truncate = truncate;
+    this.wrap = wrap;
+    this.logger.process.hijack();
+    if (!this.options?.lazy) this.spinner.start(() => {
+      this.update();
+    });
+    this.events.on("SHOUD_REFRESH_RENDER", () => {
+      this.update();
     });
-    return message2;
   }
-  fields(message2, options) {
-    if (this.options?.fields?.prefix) message2 = this.prefix(message2, ...this.options.fields.prefix);
-    if (options?.prefix) message2 = this.prefix(message2, ...options.prefix);
-    if (options?.suffix) message2 = this.suffix(message2, ...options.suffix);
-    if (this.options?.fields?.suffix) message2 = this.suffix(message2, ...this.options.fields.suffix);
-    return message2;
+  update() {
+    this.updater(this.create());
   }
-  icon(level, icon) {
-    if (!level) return null;
-    if (!icon) {
-      const i = this.options.icon?.[level];
-      icon = typeof i === "function" ? i() : i;
+  end() {
+    this.spinner.stop();
+    this.updater.clear();
+    this.updater.done();
+    if (!this.options.clearOutput) this.logger.process.toStdout(this.create({ prompt: false }));
+    this.logger.process.release();
+  }
+  create(options) {
+    options = {
+      tasks: true,
+      bottomBar: true,
+      prompt: true,
+      ...options
+    };
+    const render = [];
+    const renderTasks = this.renderer(this.tasks);
+    const renderBottomBar = this.renderBottomBar();
+    const renderPrompt = this.renderPrompt();
+    if (options.tasks && renderTasks.length > 0) render.push(...renderTasks);
+    if (options.bottomBar && renderBottomBar.length > 0) {
+      if (render.length > 0) render.push("");
+      render.push(...renderBottomBar);
     }
-    const coloring = this.options.color?.[level];
-    if (icon && coloring) icon = coloring(icon);
-    return icon;
+    if (options.prompt && renderPrompt.length > 0) {
+      if (render.length > 0) render.push("");
+      render.push(...renderPrompt);
+    }
+    return render.join(import_os2.EOL);
   }
-  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) => {
-      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);
-    return message2;
+  style(task, output = false) {
+    const rendererOptions = this.cache.rendererOptions.get(task.id);
+    if (task.isSkipped()) {
+      if (output || rendererOptions.collapseSkips) return this.logger.icon("SKIPPED_WITH_COLLAPSE");
+      else if (rendererOptions.collapseSkips === false) return this.logger.icon("SKIPPED_WITHOUT_COLLAPSE");
+    }
+    if (output) {
+      if (this.shouldOutputToBottomBar(task)) return this.logger.icon("OUTPUT_WITH_BOTTOMBAR");
+      return this.logger.icon("OUTPUT");
+    }
+    if (task.hasSubtasks()) {
+      if (task.isStarted() || task.isPrompt() && rendererOptions.showSubtasks !== false && !task.subtasks.every((subtask) => !subtask.hasTitle())) return this.logger.icon("PENDING");
+      else if (task.isCompleted() && task.subtasks.some((subtask) => subtask.hasFailed())) return this.logger.icon("COMPLETED_WITH_FAILED_SUBTASKS");
+      else if (task.hasFailed()) return this.logger.icon("FAILED_WITH_SUBTASKS");
+    }
+    if (task.isStarted() || task.isPrompt()) return this.logger.icon("PENDING", !this.options?.lazy && this.spinner.fetch());
+    else if (task.isCompleted()) return this.logger.icon("COMPLETED");
+    else if (task.isRetrying()) return this.logger.icon("RETRY", !this.options?.lazy && this.spinner.fetch());
+    else if (task.isRollingBack()) return this.logger.icon("ROLLING_BACK", !this.options?.lazy && this.spinner.fetch());
+    else if (task.hasRolledBack()) return this.logger.icon("ROLLED_BACK");
+    else if (task.hasFailed()) return this.logger.icon("FAILED");
+    else if (task.isPaused()) return this.logger.icon("PAUSED");
+    return this.logger.icon("WAITING");
   }
-  style(level, message2) {
-    if (!level || !message2) return message2;
-    const icon = this.icon(level, !this.options.useIcons && this.wrap(level));
+  format(message2, icon, level) {
+    if (message2.trim() === "") return [];
     if (icon) message2 = icon + " " + message2;
-    return message2;
-  }
-  applyFormat(message2, options) {
-    if (options?.format) return options.format(message2);
-    return message2;
-  }
-  spacing(message2) {
-    return typeof message2 === "undefined" || message2.trim() === "" ? "" : " ";
-  }
-};
-var ProcessOutputBuffer = class {
-  options;
-  buffer = [];
-  decoder = new import_string_decoder.StringDecoder();
-  constructor(options) {
-    this.options = options;
-  }
-  get all() {
-    return this.buffer;
-  }
-  get last() {
-    return this.buffer.at(-1);
-  }
-  get length() {
-    return this.buffer.length;
-  }
-  write(data, ...args) {
-    const callback = args[args.length - 1];
-    this.buffer.push({
-      time: Date.now(),
-      stream: this.options?.stream,
-      entry: this.decoder.write(typeof data === "string" ? Buffer.from(data, typeof args[0] === "string" ? args[0] : void 0) : Buffer.from(data))
-    });
-    if (this.options?.limit) this.buffer = this.buffer.slice(-this.options.limit);
-    if (typeof callback === "function") callback();
-    return true;
-  }
-  reset() {
-    this.buffer = [];
-  }
-};
-var ProcessOutputStream = class {
-  stream;
-  method;
-  buffer;
-  constructor(stream4) {
-    this.stream = stream4;
-    this.method = stream4.write;
-    this.buffer = new ProcessOutputBuffer({ stream: stream4 });
-  }
-  get out() {
-    const self2 = this;
-    return new Proxy(this.stream, { get(target, prop, receiver) {
-      if (prop === "write") return self2.write.bind(self2);
-      return Reflect.get(target, prop, receiver);
-    } });
-  }
-  hijack() {
-    this.stream.write = this.buffer.write.bind(this.buffer);
+    let parsed;
+    const columns = (process.stdout.columns ?? 80) - level * this.options.indentation - 2;
+    switch (this.options.formatOutput) {
+      case "truncate":
+        parsed = message2.split(import_os2.EOL).map((s, i) => {
+          return this.truncate(this.indent(s, i), columns);
+        });
+        break;
+      case "wrap":
+        parsed = this.wrap(message2, columns, {
+          hard: true,
+          trim: false
+        }).split(import_os2.EOL).map((s, i) => this.indent(s, i));
+        break;
+      default:
+        throw new ListrRendererError("Format option for the renderer is wrong.");
+    }
+    if (this.options.removeEmptyLines) parsed = parsed.filter(Boolean);
+    return parsed.map((str) => indent(str, level * this.options.indentation));
   }
-  release() {
-    this.stream.write = this.method;
-    const buffer = [...this.buffer.all];
-    this.buffer.reset();
-    return buffer;
+  shouldOutputToOutputBar(task) {
+    const outputBar = this.cache.rendererTaskOptions.get(task.id).outputBar;
+    return typeof outputBar === "number" && outputBar !== 0 || typeof outputBar === "boolean" && outputBar !== false;
   }
-  write(...args) {
-    return this.method.apply(this.stream, args);
+  shouldOutputToBottomBar(task) {
+    const bottomBar = this.cache.rendererTaskOptions.get(task.id).bottomBar;
+    return typeof bottomBar === "number" && bottomBar !== 0 || typeof bottomBar === "boolean" && bottomBar !== false || !task.hasTitle();
   }
-};
-var ProcessOutput = class {
-  options;
-  stream;
-  active;
-  constructor(stdout, stderr, options) {
-    this.options = options;
-    this.stream = {
-      stdout: new ProcessOutputStream(stdout ?? process.stdout),
-      stderr: new ProcessOutputStream(stderr ?? process.stderr)
-    };
-    this.options = {
-      dump: ["stdout", "stderr"],
-      leaveEmptyLine: true,
-      ...options
-    };
+  renderer(tasks, level = 0) {
+    return tasks.flatMap((task) => {
+      if (!task.isEnabled()) return [];
+      if (this.cache.render.has(task.id)) return this.cache.render.get(task.id);
+      this.calculate(task);
+      this.setupBuffer(task);
+      const rendererOptions = this.cache.rendererOptions.get(task.id);
+      const rendererTaskOptions = this.cache.rendererTaskOptions.get(task.id);
+      const output = [];
+      if (task.isPrompt()) {
+        if (this.activePrompt && this.activePrompt !== task.id) throw new ListrRendererError("Only one prompt can be active at the given time, please re-evaluate your task design.");
+        else if (!this.activePrompt) {
+          task.on("PROMPT", (prompt2) => {
+            const cleansed = cleanseAnsi(prompt2);
+            if (cleansed) this.prompt = cleansed;
+          });
+          task.on("STATE", (state) => {
+            if (state === "PROMPT_COMPLETED" || task.hasFinalized() || task.hasReset()) {
+              this.prompt = null;
+              this.activePrompt = null;
+              task.off("PROMPT");
+            }
+          });
+          this.activePrompt = task.id;
+        }
+      }
+      if (task.hasTitle()) if (!(tasks.some((task2) => task2.hasFailed()) && !task.hasFailed() && task.options.exitOnError !== false && !(task.isCompleted() || task.isSkipped()))) if (task.hasFailed() && rendererOptions.collapseErrors) output.push(...this.format(!task.hasSubtasks() && task.message.error && rendererOptions.showErrorMessage ? task.message.error : task.title, this.style(task), level));
+      else if (task.isSkipped() && rendererOptions.collapseSkips) output.push(...this.format(this.logger.suffix(task.message.skip && rendererOptions.showSkipMessage ? task.message.skip : task.title, {
+        field: "SKIPPED",
+        condition: rendererOptions.suffixSkips,
+        format: () => color.dim
+      }), this.style(task), level));
+      else if (task.isRetrying()) output.push(...this.format(this.logger.suffix(task.title, {
+        field: `${"RETRY"}:${task.message.retry.count}`,
+        format: () => color.yellow,
+        condition: rendererOptions.suffixRetries
+      }), this.style(task), level));
+      else if (task.isCompleted() && task.hasTitle() && assertFunctionOrSelf(rendererTaskOptions.timer?.condition, task.message.duration)) output.push(...this.format(this.logger.suffix(task?.title, {
+        ...rendererTaskOptions.timer,
+        args: [task.message.duration]
+      }), this.style(task), level));
+      else if (task.isPaused()) output.push(...this.format(this.logger.suffix(task.title, {
+        ...rendererOptions.pausedTimer,
+        args: [task.message.paused - Date.now()]
+      }), this.style(task), level));
+      else output.push(...this.format(task.title, this.style(task), level));
+      else output.push(...this.format(task.title, this.logger.icon("COMPLETED_WITH_SISTER_TASKS_FAILED"), level));
+      if (!task.hasSubtasks() || !rendererOptions.showSubtasks) {
+        if (task.hasFailed() && rendererOptions.collapseErrors === false && (rendererOptions.showErrorMessage || !rendererOptions.showSubtasks)) output.push(...this.dump(task, level, "FAILED"));
+        else if (task.isSkipped() && rendererOptions.collapseSkips === false && (rendererOptions.showSkipMessage || !rendererOptions.showSubtasks)) output.push(...this.dump(task, level, "SKIPPED"));
+      }
+      if (task.isPending() || rendererTaskOptions.persistentOutput) output.push(...this.renderOutputBar(task, level));
+      if (rendererOptions.showSubtasks !== false && task.hasSubtasks() && (task.isPending() || task.hasFinalized() && !task.hasTitle() || task.isCompleted() && rendererOptions.collapseSubtasks === false && !task.subtasks.some((subtask) => this.cache.rendererOptions.get(subtask.id)?.collapseSubtasks === true) || task.subtasks.some((subtask) => this.cache.rendererOptions.get(subtask.id)?.collapseSubtasks === false) || task.subtasks.some((subtask) => subtask.hasFailed()) || task.subtasks.some((subtask) => subtask.hasRolledBack()))) {
+        const subtaskLevel = !task.hasTitle() ? level : level + 1;
+        const subtaskRender = this.renderer(task.subtasks, subtaskLevel);
+        output.push(...subtaskRender);
+      }
+      if (task.hasFinalized()) {
+        if (!rendererTaskOptions.persistentOutput) {
+          this.buffer.bottom.delete(task.id);
+          this.buffer.output.delete(task.id);
+        }
+      }
+      if (task.isClosed()) {
+        this.cache.render.set(task.id, output);
+        this.reset(task);
+      }
+      return output;
+    });
   }
-  get stdout() {
-    return this.stream.stdout.out;
+  renderOutputBar(task, level) {
+    const output = this.buffer.output.get(task.id);
+    if (!output) return [];
+    return output.all.flatMap((o) => this.dump(task, level, "OUTPUT", o.entry));
   }
-  get stderr() {
-    return this.stream.stderr.out;
+  renderBottomBar() {
+    if (this.buffer.bottom.size === 0) return [];
+    return Array.from(this.buffer.bottom.values()).flatMap((output) => output.all).sort((a, b) => a.time - b.time).map((output) => output.entry);
   }
-  hijack() {
-    if (this.active) throw new Error("ProcessOutput has been already hijacked!");
-    this.stream.stdout.write(ANSI_ESCAPE_CODES.CURSOR_HIDE);
-    Object.values(this.stream).forEach((stream4) => stream4.hijack());
-    this.active = true;
+  renderPrompt() {
+    if (!this.prompt) return [];
+    return [this.prompt];
   }
-  release() {
-    const output = Object.entries(this.stream).map(([name, stream4]) => ({
-      name,
-      buffer: stream4.release()
-    })).filter((output2) => this.options.dump.includes(output2.name)).flatMap((output2) => output2.buffer).sort((a, b) => a.time - b.time).map((message2) => {
-      return {
-        ...message2,
-        entry: cleanseAnsi(message2.entry)
-      };
-    }).filter((message2) => message2.entry);
-    if (output.length > 0) {
-      if (this.options.leaveEmptyLine) this.stdout.write(import_os3.EOL);
-      output.forEach((message2) => {
-        (message2.stream ?? this.stdout).write(message2.entry + import_os3.EOL);
+  calculate(task) {
+    if (this.cache.rendererOptions.has(task.id) && this.cache.rendererTaskOptions.has(task.id)) return;
+    const rendererOptions = {
+      ...this.options,
+      ...task.rendererOptions
+    };
+    this.cache.rendererOptions.set(task.id, rendererOptions);
+    this.cache.rendererTaskOptions.set(task.id, {
+      ...DefaultRenderer2.rendererTaskOptions,
+      timer: rendererOptions.timer,
+      ...task.rendererTaskOptions
+    });
+  }
+  setupBuffer(task) {
+    if (this.buffer.bottom.has(task.id) || this.buffer.output.has(task.id)) return;
+    const rendererTaskOptions = this.cache.rendererTaskOptions.get(task.id);
+    if (this.shouldOutputToBottomBar(task) && !this.buffer.bottom.has(task.id)) {
+      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_os2.EOL));
+      });
+      task.on("STATE", (state) => {
+        switch (state) {
+          case "RETRY":
+            this.buffer.bottom.delete(task.id);
+            break;
+        }
+      });
+    } else if (this.shouldOutputToOutputBar(task) && !this.buffer.output.has(task.id)) {
+      this.buffer.output.set(task.id, new ProcessOutputBuffer({ limit: typeof rendererTaskOptions.outputBar === "number" ? rendererTaskOptions.outputBar : 1 }));
+      task.on("OUTPUT", (output) => {
+        this.buffer.output.get(task.id).write(output);
+      });
+      task.on("STATE", (state) => {
+        switch (state) {
+          case "RETRY":
+            this.buffer.output.delete(task.id);
+            break;
+        }
       });
     }
-    this.stream.stdout.write(ANSI_ESCAPE_CODES.CURSOR_SHOW);
-    this.active = false;
   }
-  toStdout(buffer, eol = true) {
-    if (eol) buffer = buffer + import_os3.EOL;
-    return this.stream.stdout.write(buffer);
-  }
-  toStderr(buffer, eol = true) {
-    if (eol) buffer = buffer + import_os3.EOL;
-    return this.stream.stderr.write(buffer);
+  reset(task) {
+    this.cache.rendererOptions.delete(task.id);
+    this.cache.rendererTaskOptions.delete(task.id);
+    this.buffer.output.delete(task.id);
   }
-};
-function createWritable(cb) {
-  const writable = new import_stream5.Writable();
-  writable.rows = Infinity;
-  writable.columns = Infinity;
-  writable.write = (chunk) => {
-    cb(chunk.toString());
-    return true;
-  };
-  return writable;
-}
-var Spinner = class {
-  spinner = !isUnicodeSupported2() ? [
-    "-",
-    "\\",
-    "|",
-    "/"
-  ] : [
-    "\u280B",
-    "\u2819",
-    "\u2839",
-    "\u2838",
-    "\u283C",
-    "\u2834",
-    "\u2826",
-    "\u2827",
-    "\u2807",
-    "\u280F"
-  ];
-  id;
-  spinnerPosition = 0;
-  spin() {
-    this.spinnerPosition = ++this.spinnerPosition % this.spinner.length;
+  dump(task, level, source = "OUTPUT", data) {
+    if (!data) switch (source) {
+      case "OUTPUT":
+        data = task.output;
+        break;
+      case "SKIPPED":
+        data = task.message.skip;
+        break;
+      case "FAILED":
+        data = task.message.error;
+        break;
+    }
+    if (task.hasTitle() && source === "FAILED" && data === task.title || typeof data !== "string") return [];
+    if (source === "OUTPUT") data = cleanseAnsi(data);
+    return this.format(data, this.style(task, true), level + 1);
   }
-  fetch() {
-    return this.spinner[this.spinnerPosition];
+  indent(str, i) {
+    return i > 0 ? indent(str.trimEnd(), this.options.indentation) : str.trimEnd();
   }
-  isRunning() {
-    return !!this.id;
+};
+var SilentRenderer = class {
+  tasks;
+  options;
+  static nonTTY = true;
+  static rendererOptions;
+  static rendererTaskOptions;
+  constructor(tasks, options) {
+    this.tasks = tasks;
+    this.options = options;
   }
-  start(cb, interval = 100) {
-    this.id = setInterval(() => {
-      this.spin();
-      if (cb) cb();
-    }, interval);
+  render() {
   }
-  stop() {
-    clearInterval(this.id);
-    this.id = void 0;
+  end() {
   }
 };
-var LISTR_DEFAULT_RENDERER_STYLE = {
-  icon: {
-    ["SKIPPED_WITH_COLLAPSE"]: figures2.arrowDown,
-    ["SKIPPED_WITHOUT_COLLAPSE"]: figures2.warning,
-    ["OUTPUT"]: figures2.pointerSmall,
-    ["OUTPUT_WITH_BOTTOMBAR"]: figures2.pointerSmall,
-    ["PENDING"]: figures2.pointer,
-    ["COMPLETED"]: figures2.tick,
-    ["COMPLETED_WITH_FAILED_SUBTASKS"]: figures2.warning,
-    ["COMPLETED_WITH_SISTER_TASKS_FAILED"]: figures2.squareSmallFilled,
-    ["RETRY"]: figures2.warning,
-    ["ROLLING_BACK"]: figures2.warning,
-    ["ROLLED_BACK"]: figures2.arrowLeft,
-    ["FAILED"]: figures2.cross,
-    ["FAILED_WITH_SUBTASKS"]: figures2.pointer,
-    ["WAITING"]: figures2.squareSmallFilled,
-    ["PAUSED"]: figures2.squareSmallFilled
-  },
-  color: {
-    ["SKIPPED_WITH_COLLAPSE"]: color.yellow,
-    ["SKIPPED_WITHOUT_COLLAPSE"]: color.yellow,
-    ["PENDING"]: color.yellow,
-    ["COMPLETED"]: color.green,
-    ["COMPLETED_WITH_FAILED_SUBTASKS"]: color.yellow,
-    ["COMPLETED_WITH_SISTER_TASKS_FAILED"]: color.red,
-    ["RETRY"]: color.yellowBright,
-    ["ROLLING_BACK"]: color.redBright,
-    ["ROLLED_BACK"]: color.redBright,
-    ["FAILED"]: color.red,
-    ["FAILED_WITH_SUBTASKS"]: color.red,
-    ["WAITING"]: color.dim,
-    ["PAUSED"]: color.yellowBright
-  }
-};
-function parseTimer(duration) {
-  const seconds = Math.floor(duration / 1e3);
-  const minutes = Math.floor(seconds / 60);
-  let parsedTime;
-  if (seconds === 0 && minutes === 0) parsedTime = `0.${Math.floor(duration / 100)}s`;
-  if (seconds > 0) parsedTime = `${seconds % 60}s`;
-  if (minutes > 0) parsedTime = `${minutes}m${parsedTime}`;
-  return parsedTime;
-}
-var PRESET_TIMER = {
-  condition: true,
-  field: parseTimer,
-  format: () => color.dim
-};
-var DefaultRenderer = class DefaultRenderer2 {
+var SimpleRenderer = class SimpleRenderer2 {
   tasks;
   options;
-  events;
-  static nonTTY = false;
-  static rendererOptions = {
-    indentation: 2,
-    clearOutput: false,
-    showSubtasks: true,
-    collapseSubtasks: true,
-    collapseSkips: true,
-    showSkipMessage: true,
-    suffixSkips: false,
-    collapseErrors: true,
-    showErrorMessage: true,
-    suffixRetries: true,
-    lazy: false,
-    removeEmptyLines: true,
-    formatOutput: "wrap",
-    pausedTimer: {
-      ...PRESET_TIMER,
-      format: () => color.yellowBright
-    }
-  };
-  static rendererTaskOptions = { outputBar: true };
-  prompt;
-  activePrompt;
-  spinner;
+  static nonTTY = true;
+  static rendererOptions = { pausedTimer: {
+    ...PRESET_TIMER,
+    field: (time) => `${"PAUSED"}:${time}`,
+    format: () => color.yellowBright
+  } };
+  static rendererTaskOptions = {};
   logger;
-  updater;
-  truncate;
-  wrap;
-  buffer = {
-    output: /* @__PURE__ */ new Map(),
-    bottom: /* @__PURE__ */ new Map()
-  };
   cache = {
-    render: /* @__PURE__ */ new Map(),
     rendererOptions: /* @__PURE__ */ new Map(),
     rendererTaskOptions: /* @__PURE__ */ new Map()
   };
-  constructor(tasks, options, events) {
+  constructor(tasks, options) {
     this.tasks = tasks;
     this.options = options;
-    this.events = events;
     this.options = {
-      ...DefaultRenderer2.rendererOptions,
-      ...this.options,
+      ...SimpleRenderer2.rendererOptions,
+      ...options,
       icon: {
-        ...LISTR_DEFAULT_RENDERER_STYLE.icon,
+        ...LISTR_LOGGER_STYLE.icon,
         ...options?.icon ?? {}
       },
       color: {
-        ...LISTR_DEFAULT_RENDERER_STYLE.color,
+        ...LISTR_LOGGER_STYLE.color,
         ...options?.color ?? {}
       }
     };
-    this.spinner = this.options.spinner ?? new Spinner();
     this.logger = this.options.logger ?? new ListrLogger({
       useIcons: true,
-      toStderr: []
+      toStderr: LISTR_LOGGER_STDERR_LEVELS
     });
     this.logger.options.icon = this.options.icon;
     this.logger.options.color = this.options.color;
-  }
-  async render() {
-    const { createLogUpdate: createLogUpdate2 } = await Promise.resolve().then(() => (init_log_update(), log_update_exports));
-    const { default: truncate } = await Promise.resolve().then(() => (init_cli_truncate(), cli_truncate_exports));
-    const { default: wrap } = await Promise.resolve().then(() => (init_wrap_ansi2(), wrap_ansi_exports));
-    this.updater = createLogUpdate2(this.logger.process.stdout);
-    this.truncate = truncate;
-    this.wrap = wrap;
-    this.logger.process.hijack();
-    if (!this.options?.lazy) this.spinner.start(() => {
-      this.update();
-    });
-    this.events.on("SHOUD_REFRESH_RENDER", () => {
-      this.update();
-    });
-  }
-  update() {
-    this.updater(this.create());
+    if (this.options.timestamp) this.logger.options.fields.prefix.unshift(this.options.timestamp);
   }
   end() {
-    this.spinner.stop();
-    this.updater.clear();
-    this.updater.done();
-    if (!this.options.clearOutput) this.logger.process.toStdout(this.create({ prompt: false }));
-    this.logger.process.release();
-  }
-  create(options) {
-    options = {
-      tasks: true,
-      bottomBar: true,
-      prompt: true,
-      ...options
-    };
-    const render = [];
-    const renderTasks = this.renderer(this.tasks);
-    const renderBottomBar = this.renderBottomBar();
-    const renderPrompt = this.renderPrompt();
-    if (options.tasks && renderTasks.length > 0) render.push(...renderTasks);
-    if (options.bottomBar && renderBottomBar.length > 0) {
-      if (render.length > 0) render.push("");
-      render.push(...renderBottomBar);
-    }
-    if (options.prompt && renderPrompt.length > 0) {
-      if (render.length > 0) render.push("");
-      render.push(...renderPrompt);
-    }
-    return render.join(import_os3.EOL);
   }
-  style(task, output = false) {
-    const rendererOptions = this.cache.rendererOptions.get(task.id);
-    if (task.isSkipped()) {
-      if (output || rendererOptions.collapseSkips) return this.logger.icon("SKIPPED_WITH_COLLAPSE");
-      else if (rendererOptions.collapseSkips === false) return this.logger.icon("SKIPPED_WITHOUT_COLLAPSE");
-    }
-    if (output) {
-      if (this.shouldOutputToBottomBar(task)) return this.logger.icon("OUTPUT_WITH_BOTTOMBAR");
-      return this.logger.icon("OUTPUT");
-    }
-    if (task.hasSubtasks()) {
-      if (task.isStarted() || task.isPrompt() && rendererOptions.showSubtasks !== false && !task.subtasks.every((subtask) => !subtask.hasTitle())) return this.logger.icon("PENDING");
-      else if (task.isCompleted() && task.subtasks.some((subtask) => subtask.hasFailed())) return this.logger.icon("COMPLETED_WITH_FAILED_SUBTASKS");
-      else if (task.hasFailed()) return this.logger.icon("FAILED_WITH_SUBTASKS");
-    }
-    if (task.isStarted() || task.isPrompt()) return this.logger.icon("PENDING", !this.options?.lazy && this.spinner.fetch());
-    else if (task.isCompleted()) return this.logger.icon("COMPLETED");
-    else if (task.isRetrying()) return this.logger.icon("RETRY", !this.options?.lazy && this.spinner.fetch());
-    else if (task.isRollingBack()) return this.logger.icon("ROLLING_BACK", !this.options?.lazy && this.spinner.fetch());
-    else if (task.hasRolledBack()) return this.logger.icon("ROLLED_BACK");
-    else if (task.hasFailed()) return this.logger.icon("FAILED");
-    else if (task.isPaused()) return this.logger.icon("PAUSED");
-    return this.logger.icon("WAITING");
-  }
-  format(message2, icon, level) {
-    if (message2.trim() === "") return [];
-    if (icon) message2 = icon + " " + message2;
-    let parsed;
-    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) => {
-          return this.truncate(this.indent(s, i), columns);
-        });
-        break;
-      case "wrap":
-        parsed = this.wrap(message2, columns, {
-          hard: true,
-          trim: false
-        }).split(import_os3.EOL).map((s, i) => this.indent(s, i));
-        break;
-      default:
-        throw new ListrRendererError("Format option for the renderer is wrong.");
-    }
-    if (this.options.removeEmptyLines) parsed = parsed.filter(Boolean);
-    return parsed.map((str) => indent(str, level * this.options.indentation));
-  }
-  shouldOutputToOutputBar(task) {
-    const outputBar = this.cache.rendererTaskOptions.get(task.id).outputBar;
-    return typeof outputBar === "number" && outputBar !== 0 || typeof outputBar === "boolean" && outputBar !== false;
-  }
-  shouldOutputToBottomBar(task) {
-    const bottomBar = this.cache.rendererTaskOptions.get(task.id).bottomBar;
-    return typeof bottomBar === "number" && bottomBar !== 0 || typeof bottomBar === "boolean" && bottomBar !== false || !task.hasTitle();
+  render() {
+    this.renderer(this.tasks);
   }
-  renderer(tasks, level = 0) {
-    return tasks.flatMap((task) => {
-      if (!task.isEnabled()) return [];
-      if (this.cache.render.has(task.id)) return this.cache.render.get(task.id);
+  renderer(tasks) {
+    tasks.forEach((task) => {
       this.calculate(task);
-      this.setupBuffer(task);
+      task.once("CLOSED", () => {
+        this.reset(task);
+      });
       const rendererOptions = this.cache.rendererOptions.get(task.id);
       const rendererTaskOptions = this.cache.rendererTaskOptions.get(task.id);
-      const output = [];
-      if (task.isPrompt()) {
-        if (this.activePrompt && this.activePrompt !== task.id) throw new ListrRendererError("Only one prompt can be active at the given time, please re-evaluate your task design.");
-        else if (!this.activePrompt) {
+      task.on("SUBTASK", (subtasks) => {
+        this.renderer(subtasks);
+      });
+      task.on("STATE", (state) => {
+        if (!task.hasTitle()) return;
+        if (state === "STARTED") this.logger.log("STARTED", task.title);
+        else if (state === "COMPLETED") {
+          const timer = rendererTaskOptions?.timer;
+          this.logger.log("COMPLETED", task.title, timer && { suffix: {
+            ...timer,
+            condition: !!task.message?.duration && timer.condition,
+            args: [task.message.duration]
+          } });
+        } else if (state === "PROMPT") {
+          this.logger.process.hijack();
           task.on("PROMPT", (prompt2) => {
-            const cleansed = cleanseAnsi(prompt2);
-            if (cleansed) this.prompt = cleansed;
-          });
-          task.on("STATE", (state) => {
-            if (state === "PROMPT_COMPLETED" || task.hasFinalized() || task.hasReset()) {
-              this.prompt = null;
-              this.activePrompt = null;
-              task.off("PROMPT");
-            }
+            this.logger.process.toStderr(prompt2, false);
           });
-          this.activePrompt = task.id;
-        }
-      }
-      if (task.hasTitle()) if (!(tasks.some((task2) => task2.hasFailed()) && !task.hasFailed() && task.options.exitOnError !== false && !(task.isCompleted() || task.isSkipped()))) if (task.hasFailed() && rendererOptions.collapseErrors) output.push(...this.format(!task.hasSubtasks() && task.message.error && rendererOptions.showErrorMessage ? task.message.error : task.title, this.style(task), level));
-      else if (task.isSkipped() && rendererOptions.collapseSkips) output.push(...this.format(this.logger.suffix(task.message.skip && rendererOptions.showSkipMessage ? task.message.skip : task.title, {
-        field: "SKIPPED",
-        condition: rendererOptions.suffixSkips,
-        format: () => color.dim
-      }), this.style(task), level));
-      else if (task.isRetrying()) output.push(...this.format(this.logger.suffix(task.title, {
-        field: `${"RETRY"}:${task.message.retry.count}`,
-        format: () => color.yellow,
-        condition: rendererOptions.suffixRetries
-      }), this.style(task), level));
-      else if (task.isCompleted() && task.hasTitle() && assertFunctionOrSelf(rendererTaskOptions.timer?.condition, task.message.duration)) output.push(...this.format(this.logger.suffix(task?.title, {
-        ...rendererTaskOptions.timer,
-        args: [task.message.duration]
-      }), this.style(task), level));
-      else if (task.isPaused()) output.push(...this.format(this.logger.suffix(task.title, {
-        ...rendererOptions.pausedTimer,
-        args: [task.message.paused - Date.now()]
-      }), this.style(task), level));
-      else output.push(...this.format(task.title, this.style(task), level));
-      else output.push(...this.format(task.title, this.logger.icon("COMPLETED_WITH_SISTER_TASKS_FAILED"), level));
-      if (!task.hasSubtasks() || !rendererOptions.showSubtasks) {
-        if (task.hasFailed() && rendererOptions.collapseErrors === false && (rendererOptions.showErrorMessage || !rendererOptions.showSubtasks)) output.push(...this.dump(task, level, "FAILED"));
-        else if (task.isSkipped() && rendererOptions.collapseSkips === false && (rendererOptions.showSkipMessage || !rendererOptions.showSubtasks)) output.push(...this.dump(task, level, "SKIPPED"));
-      }
-      if (task.isPending() || rendererTaskOptions.persistentOutput) output.push(...this.renderOutputBar(task, level));
-      if (rendererOptions.showSubtasks !== false && task.hasSubtasks() && (task.isPending() || task.hasFinalized() && !task.hasTitle() || task.isCompleted() && rendererOptions.collapseSubtasks === false && !task.subtasks.some((subtask) => this.cache.rendererOptions.get(subtask.id)?.collapseSubtasks === true) || task.subtasks.some((subtask) => this.cache.rendererOptions.get(subtask.id)?.collapseSubtasks === false) || task.subtasks.some((subtask) => subtask.hasFailed()) || task.subtasks.some((subtask) => subtask.hasRolledBack()))) {
-        const subtaskLevel = !task.hasTitle() ? level : level + 1;
-        const subtaskRender = this.renderer(task.subtasks, subtaskLevel);
-        output.push(...subtaskRender);
-      }
-      if (task.hasFinalized()) {
-        if (!rendererTaskOptions.persistentOutput) {
-          this.buffer.bottom.delete(task.id);
-          this.buffer.output.delete(task.id);
-        }
-      }
-      if (task.isClosed()) {
-        this.cache.render.set(task.id, output);
-        this.reset(task);
-      }
-      return output;
-    });
-  }
-  renderOutputBar(task, level) {
-    const output = this.buffer.output.get(task.id);
-    if (!output) return [];
-    return output.all.flatMap((o) => this.dump(task, level, "OUTPUT", o.entry));
-  }
-  renderBottomBar() {
-    if (this.buffer.bottom.size === 0) return [];
-    return Array.from(this.buffer.bottom.values()).flatMap((output) => output.all).sort((a, b) => a.time - b.time).map((output) => output.entry);
-  }
-  renderPrompt() {
-    if (!this.prompt) return [];
-    return [this.prompt];
-  }
-  calculate(task) {
-    if (this.cache.rendererOptions.has(task.id) && this.cache.rendererTaskOptions.has(task.id)) return;
-    const rendererOptions = {
-      ...this.options,
-      ...task.rendererOptions
-    };
-    this.cache.rendererOptions.set(task.id, rendererOptions);
-    this.cache.rendererTaskOptions.set(task.id, {
-      ...DefaultRenderer2.rendererTaskOptions,
-      timer: rendererOptions.timer,
-      ...task.rendererTaskOptions
-    });
-  }
-  setupBuffer(task) {
-    if (this.buffer.bottom.has(task.id) || this.buffer.output.has(task.id)) return;
-    const rendererTaskOptions = this.cache.rendererTaskOptions.get(task.id);
-    if (this.shouldOutputToBottomBar(task) && !this.buffer.bottom.has(task.id)) {
-      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));
-      });
-      task.on("STATE", (state) => {
-        switch (state) {
-          case "RETRY":
-            this.buffer.bottom.delete(task.id);
-            break;
-        }
-      });
-    } else if (this.shouldOutputToOutputBar(task) && !this.buffer.output.has(task.id)) {
-      this.buffer.output.set(task.id, new ProcessOutputBuffer({ limit: typeof rendererTaskOptions.outputBar === "number" ? rendererTaskOptions.outputBar : 1 }));
-      task.on("OUTPUT", (output) => {
-        this.buffer.output.get(task.id).write(output);
-      });
-      task.on("STATE", (state) => {
-        switch (state) {
-          case "RETRY":
-            this.buffer.output.delete(task.id);
-            break;
-        }
-      });
-    }
-  }
-  reset(task) {
-    this.cache.rendererOptions.delete(task.id);
-    this.cache.rendererTaskOptions.delete(task.id);
-    this.buffer.output.delete(task.id);
-  }
-  dump(task, level, source = "OUTPUT", data) {
-    if (!data) switch (source) {
-      case "OUTPUT":
-        data = task.output;
-        break;
-      case "SKIPPED":
-        data = task.message.skip;
-        break;
-      case "FAILED":
-        data = task.message.error;
-        break;
-    }
-    if (task.hasTitle() && source === "FAILED" && data === task.title || typeof data !== "string") return [];
-    if (source === "OUTPUT") data = cleanseAnsi(data);
-    return this.format(data, this.style(task, true), level + 1);
-  }
-  indent(str, i) {
-    return i > 0 ? indent(str.trimEnd(), this.options.indentation) : str.trimEnd();
-  }
-};
-var SilentRenderer = class {
-  tasks;
-  options;
-  static nonTTY = true;
-  static rendererOptions;
-  static rendererTaskOptions;
-  constructor(tasks, options) {
-    this.tasks = tasks;
-    this.options = options;
-  }
-  render() {
-  }
-  end() {
-  }
-};
-var SimpleRenderer = class SimpleRenderer2 {
-  tasks;
-  options;
-  static nonTTY = true;
-  static rendererOptions = { pausedTimer: {
-    ...PRESET_TIMER,
-    field: (time) => `${"PAUSED"}:${time}`,
-    format: () => color.yellowBright
-  } };
-  static rendererTaskOptions = {};
-  logger;
-  cache = {
-    rendererOptions: /* @__PURE__ */ new Map(),
-    rendererTaskOptions: /* @__PURE__ */ new Map()
-  };
-  constructor(tasks, options) {
-    this.tasks = tasks;
-    this.options = options;
-    this.options = {
-      ...SimpleRenderer2.rendererOptions,
-      ...options,
-      icon: {
-        ...LISTR_LOGGER_STYLE.icon,
-        ...options?.icon ?? {}
-      },
-      color: {
-        ...LISTR_LOGGER_STYLE.color,
-        ...options?.color ?? {}
-      }
-    };
-    this.logger = this.options.logger ?? new ListrLogger({
-      useIcons: true,
-      toStderr: LISTR_LOGGER_STDERR_LEVELS
-    });
-    this.logger.options.icon = this.options.icon;
-    this.logger.options.color = this.options.color;
-    if (this.options.timestamp) this.logger.options.fields.prefix.unshift(this.options.timestamp);
-  }
-  end() {
-  }
-  render() {
-    this.renderer(this.tasks);
-  }
-  renderer(tasks) {
-    tasks.forEach((task) => {
-      this.calculate(task);
-      task.once("CLOSED", () => {
-        this.reset(task);
-      });
-      const rendererOptions = this.cache.rendererOptions.get(task.id);
-      const rendererTaskOptions = this.cache.rendererTaskOptions.get(task.id);
-      task.on("SUBTASK", (subtasks) => {
-        this.renderer(subtasks);
-      });
-      task.on("STATE", (state) => {
-        if (!task.hasTitle()) return;
-        if (state === "STARTED") this.logger.log("STARTED", task.title);
-        else if (state === "COMPLETED") {
-          const timer = rendererTaskOptions?.timer;
-          this.logger.log("COMPLETED", task.title, timer && { suffix: {
-            ...timer,
-            condition: !!task.message?.duration && timer.condition,
-            args: [task.message.duration]
-          } });
-        } else if (state === "PROMPT") {
-          this.logger.process.hijack();
-          task.on("PROMPT", (prompt2) => {
-            this.logger.process.toStderr(prompt2, false);
-          });
-        } else if (state === "PROMPT_COMPLETED") {
-          task.off("PROMPT");
-          this.logger.process.release();
+        } else if (state === "PROMPT_COMPLETED") {
+          task.off("PROMPT");
+          this.logger.process.release();
         }
       });
       task.on("OUTPUT", (output) => {
@@ -63079,405 +62566,1142 @@ var Task = class extends ListrTaskEventManager {
       ...this.message,
       ...data
     };
-    this.emit("MESSAGE", data);
-    this.listr.events.emit("SHOUD_REFRESH_RENDER");
-  }
-  /**
-  * Update the current title of the Task and emit the neccassary events.
-  */
-  set title$(title) {
-    this.title = title;
-    this.emit("TITLE", title);
-    this.listr.events.emit("SHOUD_REFRESH_RENDER");
-  }
-  /**
-  * Current task path in the hierarchy.
-  */
-  get path() {
-    return [...this.listr.path, this.initialTitle];
-  }
-  /**
-  * Checks whether the current task with the given context should be set as enabled.
-  */
-  async check(ctx) {
-    if (this.state === "WAITING") {
-      this.enabled = await assertFunctionOrSelf(this.task?.enabled ?? true, ctx);
-      this.emit("ENABLED", this.enabled);
-      this.listr.events.emit("SHOUD_REFRESH_RENDER");
-    }
-    return this.enabled;
-  }
-  /** Returns whether this task has subtasks. */
-  hasSubtasks() {
-    return this.subtasks?.length > 0;
-  }
-  /** Returns whether this task is finalized in someform. */
-  hasFinalized() {
-    return this.isCompleted() || this.hasFailed() || this.isSkipped() || this.hasRolledBack();
-  }
-  /** Returns whether this task is in progress. */
-  isPending() {
-    return this.isStarted() || this.isPrompt() || this.hasReset();
-  }
-  /** Returns whether this task has started. */
-  isStarted() {
-    return this.state === "STARTED";
-  }
-  /** Returns whether this task is skipped. */
-  isSkipped() {
-    return this.state === "SKIPPED";
-  }
-  /** Returns whether this task has been completed. */
-  isCompleted() {
-    return this.state === "COMPLETED";
-  }
-  /** Returns whether this task has been failed. */
-  hasFailed() {
-    return this.state === "FAILED";
-  }
-  /** Returns whether this task has an active rollback task going on. */
-  isRollingBack() {
-    return this.state === "ROLLING_BACK";
-  }
-  /** Returns whether the rollback action was successful. */
-  hasRolledBack() {
-    return this.state === "ROLLED_BACK";
+    this.emit("MESSAGE", data);
+    this.listr.events.emit("SHOUD_REFRESH_RENDER");
+  }
+  /**
+  * Update the current title of the Task and emit the neccassary events.
+  */
+  set title$(title) {
+    this.title = title;
+    this.emit("TITLE", title);
+    this.listr.events.emit("SHOUD_REFRESH_RENDER");
+  }
+  /**
+  * Current task path in the hierarchy.
+  */
+  get path() {
+    return [...this.listr.path, this.initialTitle];
+  }
+  /**
+  * Checks whether the current task with the given context should be set as enabled.
+  */
+  async check(ctx) {
+    if (this.state === "WAITING") {
+      this.enabled = await assertFunctionOrSelf(this.task?.enabled ?? true, ctx);
+      this.emit("ENABLED", this.enabled);
+      this.listr.events.emit("SHOUD_REFRESH_RENDER");
+    }
+    return this.enabled;
+  }
+  /** Returns whether this task has subtasks. */
+  hasSubtasks() {
+    return this.subtasks?.length > 0;
+  }
+  /** Returns whether this task is finalized in someform. */
+  hasFinalized() {
+    return this.isCompleted() || this.hasFailed() || this.isSkipped() || this.hasRolledBack();
+  }
+  /** Returns whether this task is in progress. */
+  isPending() {
+    return this.isStarted() || this.isPrompt() || this.hasReset();
+  }
+  /** Returns whether this task has started. */
+  isStarted() {
+    return this.state === "STARTED";
+  }
+  /** Returns whether this task is skipped. */
+  isSkipped() {
+    return this.state === "SKIPPED";
+  }
+  /** Returns whether this task has been completed. */
+  isCompleted() {
+    return this.state === "COMPLETED";
+  }
+  /** Returns whether this task has been failed. */
+  hasFailed() {
+    return this.state === "FAILED";
+  }
+  /** Returns whether this task has an active rollback task going on. */
+  isRollingBack() {
+    return this.state === "ROLLING_BACK";
+  }
+  /** Returns whether the rollback action was successful. */
+  hasRolledBack() {
+    return this.state === "ROLLED_BACK";
+  }
+  /** Returns whether this task has an actively retrying task going on. */
+  isRetrying() {
+    return this.state === "RETRY";
+  }
+  /** Returns whether this task has some kind of reset like retry and rollback going on. */
+  hasReset() {
+    return this.state === "RETRY" || this.state === "ROLLING_BACK";
+  }
+  /** Returns whether enabled function resolves to true. */
+  isEnabled() {
+    return this.enabled;
+  }
+  /** Returns whether this task actually has a title. */
+  hasTitle() {
+    return typeof this?.title === "string";
+  }
+  /** Returns whether this task has a prompt inside. */
+  isPrompt() {
+    return this.state === "PROMPT";
+  }
+  /** Returns whether this task is currently paused. */
+  isPaused() {
+    return this.state === "PAUSED";
+  }
+  /** Returns whether this task is closed. */
+  isClosed() {
+    return this.closed;
+  }
+  /** Pause the given task for certain time. */
+  async pause(time) {
+    const state = this.state;
+    this.state$ = "PAUSED";
+    this.message$ = { paused: Date.now() + time };
+    await delay(time);
+    this.state$ = state;
+    this.message$ = { paused: null };
+  }
+  /** Run the current task. */
+  async run(context, wrapper) {
+    const handleResult = (result) => {
+      if (result instanceof Listr) {
+        result.options = {
+          ...this.options,
+          ...result.options
+        };
+        result.rendererClass = getRendererClass("silent");
+        this.subtasks = result.tasks;
+        result.errors = this.listr.errors;
+        this.emit("SUBTASK", this.subtasks);
+        result = result.run(context);
+      } else if (result instanceof Promise) result = result.then(handleResult);
+      else if (isReadable(result)) result = new Promise((resolve2, reject) => {
+        result.on("data", (data) => {
+          this.output$ = data.toString();
+        });
+        result.on("error", (error) => reject(error));
+        result.on("end", () => resolve2(null));
+      });
+      else if (isObservable(result)) result = new Promise((resolve2, reject) => {
+        result.subscribe({
+          next: (data) => {
+            this.output$ = data;
+          },
+          error: reject,
+          complete: resolve2
+        });
+      });
+      return result;
+    };
+    const startTime = Date.now();
+    this.state$ = "STARTED";
+    const skipped = await assertFunctionOrSelf(this.task?.skip ?? false, context);
+    if (skipped) {
+      if (typeof skipped === "string") this.message$ = { skip: skipped };
+      else if (this.hasTitle()) this.message$ = { skip: this.title };
+      else this.message$ = { skip: "Skipped task without a title." };
+      this.state$ = "SKIPPED";
+      return;
+    }
+    try {
+      const retryCount = typeof this.task?.retry === "number" && this.task.retry > 0 ? this.task.retry + 1 : typeof this.task?.retry === "object" && this.task.retry.tries > 0 ? this.task.retry.tries + 1 : 1;
+      const retryDelay = typeof this.task.retry === "object" && this.task.retry.delay;
+      for (let retries = 1; retries <= retryCount; retries++) try {
+        await handleResult(this.taskFn(context, wrapper));
+        break;
+      } catch (err) {
+        if (retries !== retryCount) {
+          this.retry = {
+            count: retries,
+            error: err
+          };
+          this.message$ = { retry: this.retry };
+          this.title$ = this.initialTitle;
+          this.output = void 0;
+          wrapper.report(err, "WILL_RETRY");
+          this.state$ = "RETRY";
+          if (retryDelay) await this.pause(retryDelay);
+        } else throw err;
+      }
+      if (this.isStarted() || this.isRetrying()) {
+        this.message$ = { duration: Date.now() - startTime };
+        this.state$ = "COMPLETED";
+      }
+    } catch (error) {
+      if (this.prompt instanceof PromptError) error = this.prompt;
+      if (this.task?.rollback) {
+        wrapper.report(error, "WILL_ROLLBACK");
+        try {
+          this.state$ = "ROLLING_BACK";
+          await this.task.rollback(context, wrapper);
+          this.message$ = { rollback: this.title };
+          this.state$ = "ROLLED_BACK";
+        } catch (err) {
+          this.state$ = "FAILED";
+          wrapper.report(err, "HAS_FAILED_TO_ROLLBACK");
+          this.close();
+          throw err;
+        }
+        if (this.listr.options?.exitAfterRollback !== false) {
+          this.close();
+          throw error;
+        }
+      } else {
+        this.state$ = "FAILED";
+        if (this.listr.options.exitOnError !== false && await assertFunctionOrSelf(this.task?.exitOnError, context) !== false) {
+          wrapper.report(error, "HAS_FAILED");
+          this.close();
+          throw error;
+        } else if (!this.hasSubtasks()) wrapper.report(error, "HAS_FAILED_WITHOUT_ERROR");
+      }
+    } finally {
+      this.close();
+    }
+  }
+  close() {
+    this.emit("CLOSED");
+    this.listr.events.emit("SHOUD_REFRESH_RENDER");
+    this.complete();
+  }
+};
+var ListrEventManager = class extends EventManager {
+};
+var Listr = class {
+  task;
+  options;
+  parentTask;
+  tasks = [];
+  errors = [];
+  ctx;
+  events;
+  path = [];
+  rendererClass;
+  rendererClassOptions;
+  rendererSelection;
+  boundSignalHandler;
+  concurrency;
+  renderer;
+  constructor(task, options, parentTask) {
+    this.task = task;
+    this.options = options;
+    this.parentTask = parentTask;
+    this.options = {
+      concurrent: false,
+      renderer: "default",
+      fallbackRenderer: "simple",
+      exitOnError: true,
+      exitAfterRollback: true,
+      collectErrors: false,
+      registerSignalListeners: true,
+      ...this.parentTask?.options ?? {},
+      ...options
+    };
+    if (this.options.concurrent === true) this.options.concurrent = Infinity;
+    else if (typeof this.options.concurrent !== "number") this.options.concurrent = 1;
+    this.concurrency = new Concurrency({ concurrency: this.options.concurrent });
+    if (parentTask) {
+      this.path = [...parentTask.listr.path, parentTask.title];
+      this.errors = parentTask.listr.errors;
+    }
+    if (this.parentTask?.listr.events instanceof ListrEventManager) this.events = this.parentTask.listr.events;
+    else this.events = new ListrEventManager();
+    if (this.options?.forceTTY || process.env["LISTR_FORCE_TTY"]) {
+      process.stdout.isTTY = true;
+      process.stderr.isTTY = true;
+    }
+    if (this.options?.forceUnicode) process.env["LISTR_FORCE_UNICODE"] = "1";
+    const renderer = getRenderer({
+      renderer: this.options.renderer,
+      rendererOptions: this.options.rendererOptions,
+      fallbackRenderer: this.options.fallbackRenderer,
+      fallbackRendererOptions: this.options.fallbackRendererOptions,
+      fallbackRendererCondition: this.options?.fallbackRendererCondition,
+      silentRendererCondition: this.options?.silentRendererCondition
+    });
+    this.rendererClass = renderer.renderer;
+    this.rendererClassOptions = renderer.options;
+    this.rendererSelection = renderer.selection;
+    this.add(task ?? []);
+    if (this.options.registerSignalListeners) {
+      this.boundSignalHandler = this.signalHandler.bind(this);
+      process.once("SIGINT", this.boundSignalHandler).setMaxListeners(0);
+    }
+  }
+  /**
+  * Whether this is the root task.
+  */
+  isRoot() {
+    return !this.parentTask;
+  }
+  /**
+  * Whether this is a subtask of another task list.
+  */
+  isSubtask() {
+    return !!this.parentTask;
+  }
+  /**
+  * Add tasks to current task list.
+  *
+  * @see {@link https://listr2.kilic.dev/task/task.html}
+  */
+  add(tasks) {
+    this.tasks.push(...this.generate(tasks));
+  }
+  /**
+  * Run the task list.
+  *
+  * @see {@link https://listr2.kilic.dev/listr/listr.html#run-the-generated-task-list}
+  */
+  async run(context) {
+    if (!this.renderer) this.renderer = new this.rendererClass(this.tasks, this.rendererClassOptions, this.events);
+    await this.renderer.render();
+    this.ctx = this.options?.ctx ?? context ?? {};
+    try {
+      await Promise.all(this.tasks.map((task) => task.check(this.ctx)));
+      await Promise.all(this.tasks.map((task) => this.concurrency.add(() => this.runTask(task))));
+      this.renderer.end();
+      this.removeSignalHandler();
+    } catch (err) {
+      if (this.options.exitOnError !== false) {
+        this.renderer.end(err);
+        this.removeSignalHandler();
+        throw err;
+      }
+    }
+    return this.ctx;
+  }
+  generate(tasks) {
+    tasks = Array.isArray(tasks) ? tasks : [tasks];
+    return tasks.map((task) => {
+      let rendererTaskOptions;
+      if (this.rendererSelection === "PRIMARY") rendererTaskOptions = task.rendererOptions;
+      else if (this.rendererSelection === "SECONDARY") rendererTaskOptions = task.fallbackRendererOptions;
+      return new Task(this, task, this.options, this.rendererClassOptions, rendererTaskOptions);
+    });
+  }
+  async runTask(task) {
+    if (!await task.check(this.ctx)) return;
+    return new TaskWrapper(task).run(this.ctx);
+  }
+  signalHandler() {
+    this.tasks?.forEach(async (task) => {
+      if (task.isPending()) task.state$ = "FAILED";
+    });
+    if (this.isRoot()) {
+      this.renderer?.end(/* @__PURE__ */ new Error("Interrupted."));
+      process.exit(127);
+    }
+  }
+  removeSignalHandler() {
+    if (this.boundSignalHandler) process.removeListener("SIGINT", this.boundSignalHandler);
+  }
+};
+
+// packages/kong-cli/src/commands/installCommand.ts
+var import_path5 = __toESM(require("path"));
+
+// packages/kong-cli/src/common/listrTaskLogger.ts
+var ListrTaskLogger = class {
+  constructor(task, logLevel = 0 /* INFO */) {
+    this.task = task;
+    this.logLevel = logLevel;
+  }
+  info(message2) {
+    this.task.output = message2;
+  }
+  debug(message2) {
+    if (this.logLevel === 3 /* DEBUG */) {
+      this.task.output = message2;
+    }
+  }
+  error(message2) {
+    if (this.logLevel >= 2 /* ERROR */) {
+      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/publishVersionCommand.ts
+var import_child_process2 = require("child_process");
+
+// packages/kong-cli/src/common/extensionContract.ts
+var import__ = __toESM(require__());
+var ajv2 = new import__.default();
+function getExtensionContract(filePath) {
+  const contract = loadJsonFile(filePath);
+  if (contract.input) {
+    ajv2.compile(contract.input);
+  }
+  if (contract.output) {
+    ajv2.compile(contract.output);
+  }
+  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;
+    this.verbose = verbose;
+    this.contractPath = contractPath;
+    this.isWin = process.platform === "win32";
+    this.defaultRendererOptions = {
+      bottomBar: this.verbose ? Infinity : true,
+      persistentOutput: true
+    };
+    const clientRequestConfigProvider = requestConfigProvider(profile);
+    this.registryClient = new RegistryClient(profile.kongBaseUrl, clientRequestConfigProvider);
+    this.managementClient = new ManagementClient(profile.kongBaseUrl, clientRequestConfigProvider);
+    const dockerVersion = (0, import_child_process2.spawnSync)("docker", ["--version"]);
+    this.hasDocker = !dockerVersion.error;
+  }
+  get wslPrefix() {
+    return this.isWin && !this.hasDocker ? "wsl" : "";
+  }
+  // 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({
+          processOutput: new ProcessOutput(process.stderr, process.stderr)
+        })
+      }
+    }).run();
+    return Number(ctx.publishDetails?.imageVersion ?? NaN);
+  }
+  *flowFactory(appName, notes) {
+    const kongJson = getKongJson();
+    if (kongJson.sdk === "kotlin" && !this.contractPath) {
+      yield {
+        title: "build extension",
+        task: async (ctx, task) => {
+          const logger = new ListrTaskLogger(task, this.verbose ? 3 /* DEBUG */ : 0 /* INFO */);
+          const cmdText = this.getKotlinBuildCmdTask();
+          const isPythonSdk = kongJson.sdk === "python";
+          ctx.contractText = await spawnCommand(cmdText, logger, !isPythonSdk);
+        },
+        rendererOptions: this.defaultRendererOptions
+      };
+    }
+    yield {
+      title: "generate schema",
+      task: async (ctx, task) => {
+        const logger = new ListrTaskLogger(task, this.verbose ? 3 /* DEBUG */ : 0 /* INFO */);
+        if (this.contractPath) {
+          const contract = getExtensionContract(this.contractPath);
+          ctx.contractText = prettyJsonObject(contract);
+        } else {
+          const isPythonSdk = kongJson.sdk === "python";
+          const cmdText = isPythonSdk ? this.getPythonSchemaCmdText() : this.getKotlinSchemaCmdTask();
+          const raw = await spawnCommand(cmdText, logger, !isPythonSdk);
+          ctx.contractText = isPythonSdk ? extractJsonObject(raw) : raw;
+        }
+      },
+      rendererOptions: this.defaultRendererOptions
+    };
+    yield {
+      title: "get publish details",
+      task: async (ctx) => {
+        ctx.publishDetails = await this.registryClient.getPublishDetails(appName);
+      }
+    };
+    yield {
+      title: "docker login",
+      task: async (ctx, task) => {
+        const publishDetails = ctx.publishDetails;
+        const regUrl = this.resolveRegistryUrl(publishDetails.repoName);
+        await spawnCommand(
+          this.dockerLoginCmdText(publishDetails.userName, publishDetails.token, regUrl),
+          new ListrTaskLogger(task, this.verbose ? 3 /* DEBUG */ : 0 /* INFO */)
+        );
+      },
+      rendererOptions: this.defaultRendererOptions
+    };
+    yield {
+      title: "docker build",
+      task: async (ctx, task) => {
+        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 */)
+        );
+      },
+      rendererOptions: this.defaultRendererOptions
+    };
+    yield {
+      title: "docker push",
+      task: async (ctx, task) => {
+        const cmd = this.dockerPushCmdText(notNull(ctx.fullImageName));
+        await spawnCommand(
+          cmd,
+          new ListrTaskLogger(task, this.verbose ? 3 /* DEBUG */ : 0 /* INFO */)
+        );
+      },
+      rendererOptions: this.defaultRendererOptions
+    };
+    yield {
+      title: "save publish details",
+      task: async (ctx, task) => {
+        const publishDetails = ctx.publishDetails;
+        let autoGeneratedContract;
+        try {
+          const parsed = JSON.parse(ctx.contractText);
+          if (!parsed || typeof parsed !== "object") {
+            throw new AppError(`Expected object got ${parsed}`);
+          }
+          autoGeneratedContract = {
+            input: parsed.input,
+            output: parsed.output
+          };
+        } catch (ex) {
+          console.warn("failed to auto-generate contract", ex);
+          autoGeneratedContract = {
+            input: null,
+            output: null
+          };
+        }
+        const inputSchema = kongJson.settings?.input?.schema ?? autoGeneratedContract.input;
+        const outputSchema = kongJson.settings?.output?.schema ?? autoGeneratedContract.output;
+        const metadata = JSON.parse(JSON.stringify(kongJson));
+        if (inputSchema || outputSchema) {
+          if (!metadata.settings) {
+            metadata.settings = {};
+          }
+          if (inputSchema) {
+            metadata.settings.input = {
+              ...metadata.settings.input || {
+                filter: jqFilter("")
+              },
+              schema: inputSchema
+            };
+          }
+          if (outputSchema) {
+            metadata.settings.output = {
+              ...metadata.settings.output || {
+                filter: jqFilter("")
+              },
+              schema: outputSchema
+            };
+          }
+        }
+        const snapshot = {
+          extensionId: kongJson.id,
+          extensionName: kongJson.name,
+          sdk: kongJson.sdk.toLowerCase(),
+          inputSchema,
+          outputSchema,
+          metadata,
+          version: Number(publishDetails.imageVersion),
+          notes,
+          checkpoint: "",
+          created: utcNow(DEFAULT_TIMEZONE),
+          createdBy: ""
+        };
+        await this.managementClient.updateExtension({
+          id: kongJson.id,
+          name: kongJson.name,
+          category: kongJson.category,
+          deprecated: false,
+          origin: "cli",
+          checkpoint: void 0,
+          createdBy: "",
+          created: utcNow(DEFAULT_TIMEZONE),
+          updated: utcNow(DEFAULT_TIMEZONE),
+          updatedBy: ""
+        });
+        await this.managementClient.createExtensionSnapshot(kongJson.id, snapshot);
+        task.output = [
+          `the version ${publishDetails.imageVersion} has been successfully published!`
+        ].join("\n");
+      },
+      rendererOptions: this.defaultRendererOptions
+    };
   }
-  /** Returns whether this task has an actively retrying task going on. */
-  isRetrying() {
-    return this.state === "RETRY";
+  resolveRegistryUrl(repoName) {
+    return repoName === "docker-registry:5000" ? "localhost:5000" : repoName;
   }
-  /** Returns whether this task has some kind of reset like retry and rollback going on. */
-  hasReset() {
-    return this.state === "RETRY" || this.state === "ROLLING_BACK";
+  dockerBuildCmdText(imageName) {
+    return `${this.wslPrefix} docker build --network=host -t ${imageName} -f Dockerfile .`;
   }
-  /** Returns whether enabled function resolves to true. */
-  isEnabled() {
-    return this.enabled;
+  dockerPushCmdText(imageName) {
+    return `${this.wslPrefix} docker push ${imageName}`;
   }
-  /** Returns whether this task actually has a title. */
-  hasTitle() {
-    return typeof this?.title === "string";
+  dockerLoginCmdText(username, password, registry3) {
+    return !this.isWin || this.wslPrefix ? `${this.wslPrefix} /bin/bash -c 'echo ${password} |docker login -u ${username} --password-stdin ${registry3}'` : `docker login -u ${username} -p ${password} ${registry3}"`;
   }
-  /** Returns whether this task has a prompt inside. */
-  isPrompt() {
-    return this.state === "PROMPT";
+  getPythonSchemaCmdText() {
+    const engine = this.isWin ? ".\\.venv\\Scripts\\python.exe" : "./.venv/bin/python";
+    const mainPyPath = resolveProjectPath("src/main.py");
+    return `${engine} ${escapePathSpaces(mainPyPath)} --schema`;
   }
-  /** Returns whether this task is currently paused. */
-  isPaused() {
-    return this.state === "PAUSED";
+  getKotlinBuildCmdTask() {
+    return `${this.wslPrefix} ./gradlew build -x test -Dquarkus.package.main-class=io.kong.sdk.function.template.QuarkusApp`;
   }
-  /** Returns whether this task is closed. */
-  isClosed() {
-    return this.closed;
+  getKotlinSchemaCmdTask() {
+    return `${this.wslPrefix} java -Dquarkus-profile=local -jar build/quarkus-app/quarkus-run.jar --schema`;
   }
-  /** Pause the given task for certain time. */
-  async pause(time) {
-    const state = this.state;
-    this.state$ = "PAUSED";
-    this.message$ = { paused: Date.now() + time };
-    await delay(time);
-    this.state$ = state;
-    this.message$ = { paused: null };
+};
+
+// 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();
   }
-  /** Run the current task. */
-  async run(context, wrapper) {
-    const handleResult = (result) => {
-      if (result instanceof Listr) {
-        result.options = {
-          ...this.options,
-          ...result.options
-        };
-        result.rendererClass = getRendererClass("silent");
-        this.subtasks = result.tasks;
-        result.errors = this.listr.errors;
-        this.emit("SUBTASK", this.subtasks);
-        result = result.run(context);
-      } else if (result instanceof Promise) result = result.then(handleResult);
-      else if (isReadable(result)) result = new Promise((resolve2, reject) => {
-        result.on("data", (data) => {
-          this.output$ = data.toString();
-        });
-        result.on("error", (error) => reject(error));
-        result.on("end", () => resolve2(null));
-      });
-      else if (isObservable(result)) result = new Promise((resolve2, reject) => {
-        result.subscribe({
-          next: (data) => {
-            this.output$ = data;
-          },
-          error: reject,
-          complete: resolve2
-        });
+  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) });
+        }
       });
-      return result;
-    };
-    const startTime = Date.now();
-    this.state$ = "STARTED";
-    const skipped = await assertFunctionOrSelf(this.task?.skip ?? false, context);
-    if (skipped) {
-      if (typeof skipped === "string") this.message$ = { skip: skipped };
-      else if (this.hasTitle()) this.message$ = { skip: this.title };
-      else this.message$ = { skip: "Skipped task without a title." };
-      this.state$ = "SKIPPED";
+    });
+    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;
     }
-    try {
-      const retryCount = typeof this.task?.retry === "number" && this.task.retry > 0 ? this.task.retry + 1 : typeof this.task?.retry === "object" && this.task.retry.tries > 0 ? this.task.retry.tries + 1 : 1;
-      const retryDelay = typeof this.task.retry === "object" && this.task.retry.delay;
-      for (let retries = 1; retries <= retryCount; retries++) try {
-        await handleResult(this.taskFn(context, wrapper));
-        break;
-      } catch (err) {
-        if (retries !== retryCount) {
-          this.retry = {
-            count: retries,
-            error: err
-          };
-          this.message$ = { retry: this.retry };
-          this.title$ = this.initialTitle;
-          this.output = void 0;
-          wrapper.report(err, "WILL_RETRY");
-          this.state$ = "RETRY";
-          if (retryDelay) await this.pause(retryDelay);
-        } else throw err;
-      }
-      if (this.isStarted() || this.isRetrying()) {
-        this.message$ = { duration: Date.now() - startTime };
-        this.state$ = "COMPLETED";
-      }
-    } catch (error) {
-      if (this.prompt instanceof PromptError) error = this.prompt;
-      if (this.task?.rollback) {
-        wrapper.report(error, "WILL_ROLLBACK");
-        try {
-          this.state$ = "ROLLING_BACK";
-          await this.task.rollback(context, wrapper);
-          this.message$ = { rollback: this.title };
-          this.state$ = "ROLLED_BACK";
-        } catch (err) {
-          this.state$ = "FAILED";
-          wrapper.report(err, "HAS_FAILED_TO_ROLLBACK");
-          this.close();
-          throw err;
-        }
-        if (this.listr.options?.exitAfterRollback !== false) {
-          this.close();
-          throw error;
-        }
-      } else {
-        this.state$ = "FAILED";
-        if (this.listr.options.exitOnError !== false && await assertFunctionOrSelf(this.task?.exitOnError, context) !== false) {
-          wrapper.report(error, "HAS_FAILED");
-          this.close();
-          throw error;
-        } else if (!this.hasSubtasks()) wrapper.report(error, "HAS_FAILED_WITHOUT_ERROR");
-      }
-    } finally {
-      this.close();
+    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;
     }
-  }
-  close() {
-    this.emit("CLOSED");
-    this.listr.events.emit("SHOUD_REFRESH_RENDER");
-    this.complete();
-  }
-};
-var ListrEventManager = class extends EventManager {
-};
-var Listr = class {
-  task;
-  options;
-  parentTask;
-  tasks = [];
-  errors = [];
-  ctx;
-  events;
-  path = [];
-  rendererClass;
-  rendererClassOptions;
-  rendererSelection;
-  boundSignalHandler;
-  concurrency;
-  renderer;
-  constructor(task, options, parentTask) {
-    this.task = task;
-    this.options = options;
-    this.parentTask = parentTask;
-    this.options = {
-      concurrent: false,
-      renderer: "default",
-      fallbackRenderer: "simple",
-      exitOnError: true,
-      exitAfterRollback: true,
-      collectErrors: false,
-      registerSignalListeners: true,
-      ...this.parentTask?.options ?? {},
-      ...options
-    };
-    if (this.options.concurrent === true) this.options.concurrent = Infinity;
-    else if (typeof this.options.concurrent !== "number") this.options.concurrent = 1;
-    this.concurrency = new Concurrency({ concurrency: this.options.concurrent });
-    if (parentTask) {
-      this.path = [...parentTask.listr.path, parentTask.title];
-      this.errors = parentTask.listr.errors;
+    if (request.method === "POST" && url2.pathname === "/v1/tests") {
+      const body = await this.readBody(request);
+      this.json(response, 200, await this.runTests(body));
+      return;
     }
-    if (this.parentTask?.listr.events instanceof ListrEventManager) this.events = this.parentTask.listr.events;
-    else this.events = new ListrEventManager();
-    if (this.options?.forceTTY || process.env["LISTR_FORCE_TTY"]) {
-      process.stdout.isTTY = true;
-      process.stderr.isTTY = true;
+    if (request.method === "POST" && url2.pathname === "/v1/deployments") {
+      const body = await this.readBody(request);
+      this.json(response, 200, this.startDeployment(body));
+      return;
     }
-    if (this.options?.forceUnicode) process.env["LISTR_FORCE_UNICODE"] = "1";
-    const renderer = getRenderer({
-      renderer: this.options.renderer,
-      rendererOptions: this.options.rendererOptions,
-      fallbackRenderer: this.options.fallbackRenderer,
-      fallbackRendererOptions: this.options.fallbackRendererOptions,
-      fallbackRendererCondition: this.options?.fallbackRendererCondition,
-      silentRendererCondition: this.options?.silentRendererCondition
-    });
-    this.rendererClass = renderer.renderer;
-    this.rendererClassOptions = renderer.options;
-    this.rendererSelection = renderer.selection;
-    this.add(task ?? []);
-    if (this.options.registerSignalListeners) {
-      this.boundSignalHandler = this.signalHandler.bind(this);
-      process.once("SIGINT", this.boundSignalHandler).setMaxListeners(0);
+    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}` });
   }
-  /**
-  * Whether this is the root task.
-  */
-  isRoot() {
-    return !this.parentTask;
+  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
+    };
   }
-  /**
-  * Whether this is a subtask of another task list.
-  */
-  isSubtask() {
-    return !!this.parentTask;
+  /** 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);
+      }
+    });
   }
   /**
-  * Add tasks to current task list.
-  *
-  * @see {@link https://listr2.kilic.dev/task/task.html}
-  */
-  add(tasks) {
-    this.tasks.push(...this.generate(tasks));
+   * 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 };
   }
   /**
-  * Run the task list.
-  *
-  * @see {@link https://listr2.kilic.dev/listr/listr.html#run-the-generated-task-list}
-  */
-  async run(context) {
-    if (!this.renderer) this.renderer = new this.rendererClass(this.tasks, this.rendererClassOptions, this.events);
-    await this.renderer.render();
-    this.ctx = this.options?.ctx ?? context ?? {};
-    try {
-      await Promise.all(this.tasks.map((task) => task.check(this.ctx)));
-      await Promise.all(this.tasks.map((task) => this.concurrency.add(() => this.runTask(task))));
-      this.renderer.end();
-      this.removeSignalHandler();
-    } catch (err) {
-      if (this.options.exitOnError !== false) {
-        this.renderer.end(err);
-        this.removeSignalHandler();
-        throw err;
+   * 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);
       }
-    }
-    return this.ctx;
-  }
-  generate(tasks) {
-    tasks = Array.isArray(tasks) ? tasks : [tasks];
-    return tasks.map((task) => {
-      let rendererTaskOptions;
-      if (this.rendererSelection === "PRIMARY") rendererTaskOptions = task.rendererOptions;
-      else if (this.rendererSelection === "SECONDARY") rendererTaskOptions = task.fallbackRendererOptions;
-      return new Task(this, task, this.options, this.rendererClassOptions, rendererTaskOptions);
     });
   }
-  async runTask(task) {
-    if (!await task.check(this.ctx)) return;
-    return new TaskWrapper(task).run(this.ctx);
-  }
-  signalHandler() {
-    this.tasks?.forEach(async (task) => {
-      if (task.isPending()) task.state$ = "FAILED";
-    });
-    if (this.isRoot()) {
-      this.renderer?.end(/* @__PURE__ */ new Error("Interrupted."));
-      process.exit(127);
+  /**
+   * 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;
   }
-  removeSignalHandler() {
-    if (this.boundSignalHandler) process.removeListener("SIGINT", this.boundSignalHandler);
-  }
-};
-
-// packages/kong-cli/src/commands/installCommand.ts
-var import_path5 = __toESM(require("path"));
-
-// packages/kong-cli/src/common/listrTaskLogger.ts
-var ListrTaskLogger = class {
-  constructor(task, logLevel = 0 /* INFO */) {
-    this.task = task;
-    this.logLevel = logLevel;
-  }
-  info(message2) {
-    this.task.output = message2;
-  }
-  debug(message2) {
-    if (this.logLevel === 3 /* DEBUG */) {
-      this.task.output = message2;
+  /** 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) };
   }
-  error(message2) {
-    if (this.logLevel >= 2 /* ERROR */) {
-      this.task.output = message2;
+  cleanupTemplates() {
+    for (const { parent } of this.templates.values()) {
+      import_fs5.default.rmSync(parent, { recursive: true, force: true });
     }
+    this.templates.clear();
   }
-  warn(message2) {
-    if (this.logLevel >= 1 /* WARN */) {
-      this.task.output = message2;
+  setStep(job, name, status) {
+    const step = job.steps.find((item) => item.name === name);
+    if (step) {
+      step.status = status;
     }
+    job.output = `${job.output}${name}: ${status}
+`;
   }
-};
-
-// packages/kong-cli/src/commands/installCommand.ts
-var InstallCommand = class {
-  constructor(verbose) {
-    this.verbose = verbose;
+  runExclusive(action) {
+    const result = this.lock.then(action, action);
+    this.lock = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
   }
-  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
-        }
+  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);
       }
-    ]).run();
+      child.stdin.end();
+    });
   }
-  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`);
+  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 {
@@ -63574,227 +63798,6 @@ var ListVersionsCommand = class {
   }
 };
 
-// packages/kong-cli/src/commands/publishVersionCommand.ts
-var import_child_process3 = require("child_process");
-
-// packages/kong-cli/src/common/extensionContract.ts
-var import__ = __toESM(require__());
-var ajv2 = new import__.default();
-function getExtensionContract(filePath) {
-  const contract = loadJsonFile(filePath);
-  if (contract.input) {
-    ajv2.compile(contract.input);
-  }
-  if (contract.output) {
-    ajv2.compile(contract.output);
-  }
-  return contract;
-}
-
-// 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";
-    this.defaultRendererOptions = {
-      bottomBar: this.verbose ? Infinity : true,
-      persistentOutput: true
-    };
-    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"]);
-    this.hasDocker = !dockerVersion.error;
-  }
-  get wslPrefix() {
-    return this.isWin && !this.hasDocker ? "wsl" : "";
-  }
-  async execute(appName, notes) {
-    await new Listr([...this.flowFactory(appName, notes)], {
-      renderer: "default",
-      rendererOptions: {
-        logger: new ListrLogger({
-          processOutput: new ProcessOutput(process.stderr, process.stderr)
-        })
-      }
-    }).run();
-  }
-  *flowFactory(appName, notes) {
-    const kongJson = getKongJson();
-    if (kongJson.sdk === "kotlin" && !this.contractPath) {
-      yield {
-        title: "build extension",
-        task: async (ctx, task) => {
-          const logger = new ListrTaskLogger(task, this.verbose ? 3 /* DEBUG */ : 0 /* INFO */);
-          const cmdText = this.getKotlinBuildCmdTask();
-          const isPythonSdk = kongJson.sdk === "python";
-          ctx.contractText = await spawnCommand(cmdText, logger, !isPythonSdk);
-        },
-        rendererOptions: this.defaultRendererOptions
-      };
-    }
-    yield {
-      title: "generate schema",
-      task: async (ctx, task) => {
-        const logger = new ListrTaskLogger(task, this.verbose ? 3 /* DEBUG */ : 0 /* INFO */);
-        if (this.contractPath) {
-          const contract = getExtensionContract(this.contractPath);
-          ctx.contractText = prettyJsonObject(contract);
-        } else {
-          const isPythonSdk = kongJson.sdk === "python";
-          const cmdText = isPythonSdk ? this.getPythonSchemaCmdText() : this.getKotlinSchemaCmdTask();
-          ctx.contractText = await spawnCommand(cmdText, logger, !isPythonSdk);
-        }
-      },
-      rendererOptions: this.defaultRendererOptions
-    };
-    yield {
-      title: "get publish details",
-      task: async (ctx) => {
-        ctx.publishDetails = await this.registryClient.getPublishDetails(appName);
-      }
-    };
-    yield {
-      title: "docker login",
-      task: async (ctx, task) => {
-        const publishDetails = ctx.publishDetails;
-        const regUrl = this.resolveRegistryUrl(publishDetails.repoName);
-        await spawnCommand(
-          this.dockerLoginCmdText(publishDetails.userName, publishDetails.token, regUrl),
-          new ListrTaskLogger(task, this.verbose ? 3 /* DEBUG */ : 0 /* INFO */)
-        );
-      },
-      rendererOptions: this.defaultRendererOptions
-    };
-    yield {
-      title: "docker build",
-      task: async (ctx, task) => {
-        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 */)
-        );
-      },
-      rendererOptions: this.defaultRendererOptions
-    };
-    yield {
-      title: "docker push",
-      task: async (ctx, task) => {
-        const cmd = this.dockerPushCmdText(ctx.fullImageName);
-        await spawnCommand(
-          cmd,
-          new ListrTaskLogger(task, this.verbose ? 3 /* DEBUG */ : 0 /* INFO */)
-        );
-      },
-      rendererOptions: this.defaultRendererOptions
-    };
-    yield {
-      title: "save publish details",
-      task: async (ctx, task) => {
-        const publishDetails = ctx.publishDetails;
-        let autoGeneratedContract;
-        try {
-          const parsed = JSON.parse(ctx.contractText);
-          if (!parsed || typeof parsed !== "object") {
-            throw new AppError(`Expected object got ${parsed}`);
-          }
-          autoGeneratedContract = {
-            input: parsed.input,
-            output: parsed.output
-          };
-        } catch (ex) {
-          console.warn("failed to auto-generate contract", ex);
-          autoGeneratedContract = {
-            input: null,
-            output: null
-          };
-        }
-        const inputSchema = kongJson.settings?.input?.schema ?? autoGeneratedContract.input;
-        const outputSchema = kongJson.settings?.output?.schema ?? autoGeneratedContract.output;
-        const metadata = JSON.parse(JSON.stringify(kongJson));
-        if (inputSchema || outputSchema) {
-          if (!metadata.settings) {
-            metadata.settings = {};
-          }
-          if (inputSchema) {
-            metadata.settings.input = {
-              ...metadata.settings.input || {
-                filter: jqFilter("")
-              },
-              schema: inputSchema
-            };
-          }
-          if (outputSchema) {
-            metadata.settings.output = {
-              ...metadata.settings.output || {
-                filter: jqFilter("")
-              },
-              schema: outputSchema
-            };
-          }
-        }
-        const snapshot = {
-          extensionId: kongJson.id,
-          extensionName: kongJson.name,
-          sdk: kongJson.sdk.toLowerCase(),
-          inputSchema,
-          outputSchema,
-          metadata,
-          version: Number(publishDetails.imageVersion),
-          notes,
-          checkpoint: "",
-          created: utcNow(DEFAULT_TIMEZONE),
-          createdBy: ""
-        };
-        await this.managementClient.updateExtension({
-          id: kongJson.id,
-          name: kongJson.name,
-          category: kongJson.category,
-          deprecated: false,
-          origin: "cli",
-          checkpoint: void 0,
-          createdBy: "",
-          created: utcNow(DEFAULT_TIMEZONE),
-          updated: utcNow(DEFAULT_TIMEZONE),
-          updatedBy: ""
-        });
-        await this.managementClient.createExtensionSnapshot(kongJson.id, snapshot);
-        task.output = [
-          `the version ${publishDetails.imageVersion} has been successfully published!`
-        ].join("\n");
-      },
-      rendererOptions: this.defaultRendererOptions
-    };
-  }
-  resolveRegistryUrl(repoName) {
-    return repoName === "docker-registry:5000" ? "localhost:5000" : repoName;
-  }
-  dockerBuildCmdText(imageName) {
-    return `${this.wslPrefix} docker build --network=host -t ${imageName} -f Dockerfile .`;
-  }
-  dockerPushCmdText(imageName) {
-    return `${this.wslPrefix} docker push ${imageName}`;
-  }
-  dockerLoginCmdText(username, password, registry3) {
-    return !this.isWin || this.wslPrefix ? `${this.wslPrefix} /bin/bash -c 'echo ${password} |docker login -u ${username} --password-stdin ${registry3}'` : `docker login -u ${username} -p ${password} ${registry3}"`;
-  }
-  getPythonSchemaCmdText() {
-    const engine = this.isWin ? ".\\.venv\\Scripts\\python.exe" : "./.venv/bin/python";
-    const mainPyPath = resolveProjectPath("src/main.py");
-    return `${engine} ${escapePathSpaces(mainPyPath)} --schema`;
-  }
-  getKotlinBuildCmdTask() {
-    return `${this.wslPrefix} ./gradlew build -x test -Dquarkus.package.main-class=io.kong.sdk.function.template.QuarkusApp`;
-  }
-  getKotlinSchemaCmdTask() {
-    return `${this.wslPrefix} java -Dquarkus-profile=local -jar build/quarkus-app/quarkus-run.jar --schema`;
-  }
-};
-
 // 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"]);
@@ -64081,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() {