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

package/index.js

@@ -61109,11 +61109,28 @@ 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);
@@ -61155,7 +61172,17 @@ var ConnectCommand = class {
     }
     if (request.method === "POST" && url2.pathname === "/v1/deployments") {
       const body = await this.readBody(request);
-      this.json(response, 200, await this.deploy(body));
+      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}` });
@@ -61189,38 +61216,80 @@ var ConnectCommand = class {
       import_fs3.default.rmSync(workDir, { recursive: true, force: true });
     }
   }
+  /**
+   * 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 };
+  }
   /**
    * 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) {
+  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;
+      }
+    };
     const workDir = this.materialize(request.files);
     try {
       const log = [];
       import_fs3.default.writeFileSync(import_path4.default.join(workDir, "Dockerfile"), DOCKERFILE);
-      const prepared = await this.prepareVenv(workDir, log);
-      if (prepared.exitCode !== 0) {
-        throw new Error(`dependency install failed:
+      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 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:
+        }
+      });
+      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}`);
-      }
-      const contract = JSON.parse(schema.output);
-      const tenant = parseTenant(this.profile.kongBaseUrl);
-      const publishDetails = await this.registryClient.getPublishDetails(
-        `${tenant}-k-extension-${request.extensionId}`
-      );
+        }
+        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 step of [
+      for (const dockerStep of [
         {
           title: "docker login",
           command: "docker",
@@ -61234,21 +61303,34 @@ ${schema.output}`);
         },
         { title: "docker push", command: "docker", args: ["push", imageName] }
       ]) {
-        log.push(`> ${step.title}`);
-        const result = await this.run(step.command, step.args, workDir, step.stdin);
-        log.push(result.output);
-        if (result.exitCode !== 0) {
-          throw new Error(`${step.title} failed:
-${log.join("\n")}`);
-        }
+        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 this.managementClient.createExtensionSnapshot(
-        request.extensionId,
-        this.snapshotFor(request, version, contract)
+      await runStep(
+        "save publish details",
+        () => this.managementClient.createExtensionSnapshot(
+          request.extensionId,
+          this.snapshotFor(request, version, contract)
+        )
       );
       log.push(`the version ${version} has been successfully published!`);
-      return { version, output: log.join("\n") };
+      job.output = log.join("\n");
+      job.version = version;
+      job.status = "succeeded";
     } finally {
       import_fs3.default.rmSync(workDir, { recursive: true, force: true });
     }
@@ -63860,13 +63942,13 @@ function parseVersionWeightList(list) {
   }
   return uses;
 }
-var DEPLOY_STEPS = [
+var DEPLOY_STEPS2 = [
   "create deployment",
   "save deployment details",
   "deployment completed"
 ];
 function createDeploySteps() {
-  return DEPLOY_STEPS.map((action) => {
+  return DEPLOY_STEPS2.map((action) => {
     const handlers = {
       resolve: () => void 0,
       reject: () => void 0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devkong/cli",
-  "version": "0.0.67-alpha.26",
+  "version": "0.0.67-alpha.27",
   "type": "commonjs",
   "main": "./index.js",
   "typings": "./index.d.ts",

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

@@ -5,12 +5,18 @@ export declare class ConnectCommand {
     private readonly isWin;
     private readonly registryClient;
     private readonly managementClient;
+    private readonly deployments;
     constructor(profileName: ProfileName, profile: Profile);
     execute(): Promise<void>;
     private handle;
     private profileInfo;
     /** Runs only src/main_test.py in a fresh venv and returns the raw output. */
     private runTests;
+    /**
+     * Deployments are asynchronous: the ui polls GET /v1/deployments/{id} and
+     * renders the steps in the same progress dialog as the kong-build path.
+     */
+    private startDeployment;
     /**
      * The client-side twin of the kong-build pipeline: docker build + push from
      * this machine (requirements.txt applied), schema generated locally with

package/packages/kong-ts/src/index.d.ts

@@ -5,7 +5,7 @@ export { CloudEvent } from "./lib/cloudEvent";
 export { textToBackground, textToColor, textToMonoGradient } from "./lib/color";
 export { deepEquals, prepareTextForComparison, sameText, shadowEquals } from "./lib/compare";
 export { KONG_CONNECT_BASE_URL, KONG_CONNECT_PORT } from "./lib/connect";
-export type { KongConnectDeployRequest, KongConnectDeployResult, KongConnectFile, KongConnectProfile, KongConnectTestRequest, KongConnectTestResult, } from "./lib/connect";
+export type { KongConnectDeployRequest, KongConnectDeployStart, KongConnectDeployStatus, KongConnectDeployStep, KongConnectFile, KongConnectProfile, KongConnectStepStatus, KongConnectTestRequest, KongConnectTestResult, } from "./lib/connect";
 export { cronToText, isCron } from "./lib/cron";
 export type { Cron } from "./lib/cron";
 export { DataGuardType } from "./lib/dataGuard";

package/packages/kong-ts/src/lib/connect.d.ts

@@ -25,7 +25,18 @@ export interface KongConnectDeployRequest {
     files: KongConnectFile[];
     notes?: string;
 }
-export interface KongConnectDeployResult {
-    version: number;
+export interface KongConnectDeployStart {
+    deploymentId: string;
+}
+export type KongConnectStepStatus = "idle" | "pending" | "succeeded" | "failed";
+export interface KongConnectDeployStep {
+    name: string;
+    status: KongConnectStepStatus;
+}
+export interface KongConnectDeployStatus {
+    status: "pending" | "succeeded" | "failed";
+    steps: KongConnectDeployStep[];
     output: string;
+    version?: number;
+    error?: string;
 }