libretto 0.5.3-experimental.0 → 0.5.3-experimental.2

package/dist/cli/commands/deploy.js

@@ -0,0 +1,149 @@
+import { z } from "zod";
+import { buildHostedDeployTarball } from "../core/deploy-artifact.js";
+import { SimpleCLI } from "../framework/simple-cli.js";
+function getConfig() {
+  const apiUrl = process.env.LIBRETTO_API_URL;
+  const apiKey = process.env.LIBRETTO_API_KEY;
+  if (!apiUrl) {
+    throw new Error(
+      "LIBRETTO_API_URL environment variable is required."
+    );
+  }
+  if (!apiKey) {
+    throw new Error(
+      "LIBRETTO_API_KEY environment variable is required."
+    );
+  }
+  return { apiUrl: apiUrl.replace(/\/$/, ""), apiKey };
+}
+async function postJson(apiUrl, apiKey, path, input = {}) {
+  return fetch(`${apiUrl}${path}`, {
+    method: "POST",
+    headers: {
+      "x-api-key": apiKey,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ json: input })
+  });
+}
+async function pollDeployment(apiUrl, apiKey, deploymentId, pollIntervalMs, maxWaitMs) {
+  const start = Date.now();
+  let status = "building";
+  let deployment;
+  while (status === "building" && Date.now() - start < maxWaitMs) {
+    await new Promise((r) => setTimeout(r, pollIntervalMs));
+    const res = await postJson(apiUrl, apiKey, "/v1/deployments/get", {
+      id: deploymentId
+    });
+    const body = await res.json();
+    if (res.status !== 200) {
+      throw new Error(
+        `Failed to get deployment status (${res.status}): ${JSON.stringify(body)}`
+      );
+    }
+    status = body.json.status;
+    deployment = body.json;
+    process.stdout.write(".");
+  }
+  console.log();
+  if (!deployment) {
+    throw new Error("Deployment timed out before receiving a status update.");
+  }
+  return deployment;
+}
+const deployInput = SimpleCLI.input({
+  positionals: [
+    SimpleCLI.positional("sourceDir", z.string().default("."), {
+      help: "Path to source directory (default: current directory)"
+    })
+  ],
+  named: {
+    name: SimpleCLI.option(z.string(), {
+      help: "Deployment name"
+    }),
+    description: SimpleCLI.option(z.string().optional(), {
+      help: "Deployment description"
+    }),
+    entryPoint: SimpleCLI.option(z.string().optional(), {
+      name: "entry-point",
+      help: "Entry point file (default: index.ts)"
+    }),
+    external: SimpleCLI.option(
+      z.string().optional().transform(
+        (value) => value?.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0) ?? []
+      ),
+      {
+        help: "Comma-separated packages to externalize and install at runtime"
+      }
+    )
+  }
+});
+const deployCommand = SimpleCLI.command({
+  description: "[experimental] Deploy workflows to the hosted platform",
+  experimental: true
+}).input(deployInput).handle(async ({ input }) => {
+  const { apiUrl, apiKey } = getConfig();
+  console.log("Bundling hosted deployment artifact...");
+  const { entryPoint, source } = await buildHostedDeployTarball({
+    additionalExternals: input.external,
+    deploymentName: input.name,
+    entryPoint: input.entryPoint,
+    sourceDir: input.sourceDir
+  });
+  const createPayload = {
+    name: input.name,
+    source,
+    entry_point: entryPoint
+  };
+  if (input.description) createPayload.description = input.description;
+  console.log("Uploading deployment...");
+  const res = await postJson(
+    apiUrl,
+    apiKey,
+    "/v1/deployments/create",
+    createPayload
+  );
+  const body = await res.json();
+  if (res.status !== 200) {
+    throw new Error(
+      `Failed to create deployment (${res.status}): ${JSON.stringify(body)}`
+    );
+  }
+  const { deployment_id, name, version, status } = body.json;
+  console.log(
+    `Deployment created: ${name} v${version} (${deployment_id})`
+  );
+  console.log(`Status: ${status}`);
+  if (status === "building") {
+    process.stdout.write("Waiting for build");
+    const deployment = await pollDeployment(
+      apiUrl,
+      apiKey,
+      deployment_id,
+      1e4,
+      5 * 60 * 1e3
+    );
+    if (deployment.status === "failed") {
+      throw new Error(
+        `Build failed: ${deployment.build_error ?? "unknown error"}`
+      );
+    }
+    if (deployment.status === "ready") {
+      console.log(`Build complete.`);
+      if (deployment.workflows?.length) {
+        console.log(
+          `Workflows: ${deployment.workflows.join(", ")}`
+        );
+      }
+    } else {
+      console.log(
+        `Build still in progress (timed out waiting). Check status with deployment ID: ${deployment_id}`
+      );
+    }
+  }
+  return deployment_id;
+});
+export {
+  deployCommand,
+  deployInput
+};