@get-dx/cli 0.3.3 → 0.3.5

package/assets/logo-d.txt

@@ -0,0 +1,21 @@
+
+
+
+
+ ████████████████
+   █████████████████
+     ████████████████
+██████         ████████
+██████          ███████
+██████           ███████
+██████           ███████
+██████           ███████
+██████           ███████
+██████          ███████
+██████         ████████
+██████████████████████
+████████████████████
+█████████████████
+
+
+

package/assets/logo-x.txt

@@ -0,0 +1,21 @@
+
+
+
+
+                        ███████         ████████
+                         ███████       ███████
+                          ███████     ███████
+                            ████    ████████
+                             ██    ███████
+                                  ███████
+                                ████████
+                               ███████
+                              ███████
+                            ████████    █
+                           ████████   █████
+                          ███████     ██████
+                        ████████      ███████
+                       ████████        ████████
+
+
+

package/assets/logo.txt

@@ -0,0 +1,21 @@
+
+
+
+
+ ████████████████       ███████         ████████
+   █████████████████     ███████       ███████
+     ████████████████     ███████     ███████
+██████         ████████     ████    ████████
+██████          ███████      ██    ███████
+██████           ███████          ███████
+██████           ███████        ████████
+██████           ███████       ███████
+██████           ███████      ███████
+██████          ███████     ████████    █
+██████         ████████    ████████   █████
+██████████████████████    ███████     ██████
+████████████████████    ████████      ███████
+█████████████████      ████████        ████████
+
+
+

package/dist/commands/workflowRuns/parameters.js

@@ -0,0 +1,163 @@
+import { input, select, confirm, search } from "@inquirer/prompts";
+import { listTeams } from "../teams.js";
+import { CliError, EXIT_CODES } from "../../errors.js";
+import { renderRichText } from "../../renderers.js";
+import * as ui from "../../ui.js";
+export async function promptForParameterValue(runtime, param) {
+    const message = param.description
+        ? `${param.name}: ${param.description}`
+        : param.name;
+    switch (param.type) {
+        case "STRING": {
+            const rawValue = await input({
+                message,
+                default: param.default_value
+                    ? param.default_value
+                    : undefined,
+                validate: (value) => {
+                    if (value === "" && !param.is_required) {
+                        return true;
+                    }
+                    else if (value === "") {
+                        return "Value is required";
+                    }
+                    return true;
+                },
+            });
+            return rawValue === "" ? undefined : rawValue;
+        }
+        case "INTEGER": {
+            const rawValue = await input({
+                message,
+                default: param.default_value
+                    ? param.default_value
+                    : undefined,
+                validate: (value) => {
+                    if (value === "" && !param.is_required) {
+                        return true;
+                    }
+                    else if (value === "") {
+                        return "Value is required";
+                    }
+                    const num = Number(value);
+                    if (isNaN(num)) {
+                        return "Value must be a number";
+                    }
+                    else if (num % 1 !== 0) {
+                        return "Value must be an integer";
+                    }
+                    else {
+                        return true;
+                    }
+                },
+            });
+            return rawValue === "" ? undefined : Number(rawValue);
+        }
+        case "FLOAT": {
+            const rawValue = await input({
+                message,
+                default: param.default_value
+                    ? param.default_value
+                    : undefined,
+                validate: (value) => {
+                    if (value === "" && !param.is_required) {
+                        return true;
+                    }
+                    else if (value === "") {
+                        return "Value is required";
+                    }
+                    const num = Number(value);
+                    if (isNaN(num)) {
+                        return "Value must be a number";
+                    }
+                    else {
+                        return true;
+                    }
+                },
+            });
+            return rawValue === "" ? undefined : Number(rawValue);
+        }
+        case "BOOLEAN":
+            return await confirm({
+                message,
+                default: false,
+            });
+        case "SELECT": {
+            return await select({
+                message,
+                default: param.default_value
+                    ? param.default_value
+                    : undefined,
+                choices: param.definition.options.map((option) => ({
+                    name: option,
+                    value: option,
+                })),
+            });
+        }
+        case "USER":
+            throw new CliError("User-based parameters are not yet supported in the CLI", EXIT_CODES.ARGUMENT_ERROR);
+        case "TEAM": {
+            renderRichText([ui.p("Fetching teams...")]);
+            const teamsResponse = await listTeams(runtime);
+            const teams = teamsResponse.teams;
+            const teamId = await search({
+                message,
+                source: (term) => teams
+                    .filter((team) => term === undefined ||
+                    team.name.toLowerCase().includes(term.toLowerCase()))
+                    .map((team) => ({
+                    name: team.name,
+                    value: team.id,
+                })),
+            });
+            // TODO: change the trigger endpoint to accept encoded IDs too
+            const decodedTeamId = decodeBase64(teamId);
+            return decodedTeamId;
+        }
+        case "EMAIL": {
+            const rawValue = await input({
+                message,
+                default: param.default_value
+                    ? param.default_value
+                    : undefined,
+                validate: (value) => {
+                    if (value === "" && !param.is_required) {
+                        return true;
+                    }
+                    else if (value === "") {
+                        return "Value is required";
+                    }
+                    else if (!isValidEmail(value)) {
+                        return "Value must be a valid email address";
+                    }
+                    return true;
+                },
+            });
+            return rawValue === "" ? undefined : rawValue;
+        }
+        default:
+            throw new CliError(`Unknown parameter type: ${param.type}`, EXIT_CODES.ARGUMENT_ERROR);
+    }
+}
+export function renderParameterData(parameters, data) {
+    const items = [];
+    for (const parameter of parameters) {
+        items.push(ui.p(parameter.description
+            ? `${ui.bold(parameter.name)}  ${ui.dim(parameter.description)}`
+            : ui.bold(parameter.name), false));
+        if (data[parameter.identifier] !== undefined) {
+            items.push(ui.p(`  ${ui.code(String(data[parameter.identifier]))}`));
+        }
+        else {
+            items.push(ui.p(`  ${ui.dim("(none)")}`));
+        }
+    }
+    items.push(ui.blankLine());
+    renderRichText(items, { useStderr: true });
+}
+function decodeBase64(value) {
+    return Buffer.from(value, "base64").toString("utf-8");
+}
+function isValidEmail(value) {
+    return /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/.test(value);
+}

package/dist/commands/workflowRuns/trigger.js

@@ -0,0 +1,286 @@
+import { Command } from "commander";
+import { confirm } from "@inquirer/prompts";
+import { createExampleText, getContext, wrapAction, } from "../../commandHelpers.js";
+import { CliError, EXIT_CODES, HttpError } from "../../errors.js";
+import { request } from "../../http.js";
+import { renderJson, renderRichText } from "../../renderers.js";
+import { buildRuntime } from "../../runtime.js";
+import * as ui from "../../ui.js";
+import { listWorkflows } from "../workflows.js";
+import { promptForParameterValue, renderParameterData } from "./parameters.js";
+import { getWorkflowRun, renderWorkflowRunSummary, } from "./info.js";
+import { workflowRunEventContent } from "./events.js";
+const POLL_INTERVAL_MS = 1000;
+const PENDING_WORKFLOW_RUN_STATUSES = new Set([
+    "PENDING_RUN",
+    "IN_PROGRESS",
+    "WAITING_FOR_APPROVAL",
+    "WAITING_FOR_EVENTS",
+]);
+const TERMINAL_SUCCESS = new Set(["SUCCEEDED"]);
+const TERMINAL_FAILURE = new Set([
+    "FAILED",
+    "REJECTED",
+    "TIMEOUT",
+    "CANCELLED",
+]);
+export function triggerCommand() {
+    return new Command()
+        .name("trigger")
+        .description("Trigger a Self-service workflow run and wait until it succeeds or fails. If the workflow requires approval, this command will submit a request and optionally notify approvers.")
+        .argument("<workflow-identifier>", "Workflow identifier (from dx workflows list)")
+        .option("--entity <identifier>", "Catalog entity identifier (required for entity-scoped workflows)")
+        .option("--param <key=value>", "Workflow parameter value (repeatable). Value after the first '=' is kept verbatim", (val, prev) => [...prev, val], [])
+        .option("--notify-approvers <boolean>", "For workflows that require approval, send a message to each approver requesting review")
+        .addHelpText("afterAll", createExampleText([
+        {
+            label: "Trigger a global workflow and wait for completion",
+            command: "dx workflowRuns trigger my-global-workflow",
+        },
+        {
+            label: "Trigger with an entity and parameters",
+            command: 'dx workflowRuns trigger provision-db --entity acme-api --param size=small --param "greeting=hello world"',
+        },
+        {
+            label: "Trigger with machine-readable output",
+            command: "dx workflowRuns trigger my-workflow --json --entity svc-1 --param count=3",
+        },
+        {
+            label: "Request approval to trigger a workflow but do not notify approvers",
+            command: "dx workflowRuns trigger workflow-requiring-approval --notify-approvers false",
+        },
+    ]))
+        .action(wrapAction(async (workflowIdentifier, options, command) => {
+        const context = getContext(command);
+        const runtime = buildRuntime(context);
+        // Fetch list of all workflows, find the one that applies
+        const workflowsResponse = await listWorkflows(runtime, {});
+        const workflow = workflowsResponse.workflows.find((w) => w.identifier === workflowIdentifier);
+        if (!workflow) {
+            throw new CliError(`Workflow \`${workflowIdentifier}\` not found`, EXIT_CODES.ARGUMENT_ERROR);
+        }
+        const requiresApproval = workflow.trigger_type === "APPROVAL";
+        const entityIdentifier = parseOptionalTrimmed(options.entity);
+        if (entityIdentifier === undefined && workflow.scope === "ENTITY") {
+            throw new CliError("--entity is required for entity-scoped workflows", EXIT_CODES.ARGUMENT_ERROR);
+        }
+        // Collect parameter data
+        const parameterData = parseParameterData(options.param);
+        if (isInteractive()) {
+            for (const param of workflow.parameters) {
+                if (parameterData[param.identifier] !== undefined) {
+                    continue;
+                }
+                parameterData[param.identifier] = await promptForParameterValue(runtime, param);
+            }
+        }
+        let notifyApprovers = true;
+        if (requiresApproval && options.notifyApprovers !== undefined) {
+            notifyApprovers = options.notifyApprovers === "true";
+        }
+        else if (requiresApproval && isInteractive()) {
+            notifyApprovers = await confirm({
+                message: "Notify approvers?",
+                default: true,
+            });
+        }
+        if (isInteractive()) {
+            // Confirm everything looks right
+            renderRichText([ui.blankLine(), ui.h3("Confirm"), ui.blankLine()], {
+                useStderr: true,
+            });
+            if (entityIdentifier !== undefined) {
+                renderRichText([
+                    ui.p(`${ui.bold("Entity")}`, false),
+                    ui.p(`  ${ui.code(entityIdentifier)}`),
+                    ui.blankLine(),
+                ], {
+                    useStderr: true,
+                });
+            }
+            if (workflow.parameters.length > 0) {
+                renderParameterData(workflow.parameters, parameterData);
+            }
+            const confirmationMessage = requiresApproval
+                ? "Request approval to trigger this workflow run with these settings?"
+                : "Trigger this workflow run with these settings?";
+            const isConfirmed = await confirm({
+                message: confirmationMessage,
+                default: true,
+            });
+            if (!isConfirmed) {
+                throw new CliError("Workflow run not confirmed", EXIT_CODES.RETRY_RECOMMENDED);
+            }
+        }
+        // Create the request body
+        const triggerRequestBody = {
+            workflow_identifier: workflowIdentifier.trim(),
+        };
+        if (entityIdentifier !== undefined) {
+            triggerRequestBody.entity_identifier = entityIdentifier;
+        }
+        if (Object.keys(parameterData).length > 0) {
+            triggerRequestBody.data = parameterData;
+        }
+        if (requiresApproval) {
+            triggerRequestBody.notify_approvers = notifyApprovers;
+        }
+        // Trigger the workflow
+        let runId;
+        try {
+            const triggerResponse = await triggerWorkflowRun(runtime, triggerRequestBody);
+            runId = triggerResponse.body.workflow_run.id;
+        }
+        catch (error) {
+            renderRichText([
+                ui.p(`${ui.error(ui.GLYPHS.ERROR)} Failed to trigger workflow run.`),
+            ], { useStderr: true });
+            throw error;
+        }
+        renderRichText([
+            ui.blankLine(),
+            ui.p(`Workflow run ${ui.code(runId)} triggered.`, false),
+            ui.p(`Web link: ${ui.link(ui.webLink(`/self-service/workflow-runs/${runId}`, runtime))}`),
+            ui.blankLine(),
+        ], { useStderr: true });
+        // Poll for updates
+        try {
+            await sleep(POLL_INTERVAL_MS);
+            renderRichText([ui.h3("Events"), ui.blankLine()], {
+                useStderr: true,
+            });
+            const finalDetail = await pollForWorkflowRunInfo(runtime, runId);
+            if (runtime.context.json) {
+                renderJson({ ok: true, workflow_run: finalDetail });
+            }
+            else {
+                renderRichText([
+                    ui.blankLine(),
+                    ui.p(`${ui.success(ui.GLYPHS.CHECK)} Workflow run ${ui.code(finalDetail.id)} completed with status ${ui.bold(finalDetail.status)}.`),
+                    ui.blankLine(),
+                ]);
+                renderWorkflowRunSummary(finalDetail, runtime);
+            }
+        }
+        catch (error) {
+            renderRichText([
+                ui.blankLine(),
+                ui.p(`${ui.error(ui.GLYPHS.ERROR)} Workflow run failed.`),
+            ], { useStderr: true });
+            throw error;
+        }
+    }));
+}
+// TODO: move somewhere central
+function isInteractive() {
+    return process.stdin.isTTY && process.stdout.isTTY && process.stderr.isTTY;
+}
+function parseOptionalTrimmed(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const t = value.trim();
+    return t.length > 0 ? t : undefined;
+}
+function parseParameterData(pairs) {
+    if (pairs.length === 0) {
+        return {};
+    }
+    const result = {};
+    for (const pair of pairs) {
+        const eqIdx = pair.indexOf("=");
+        if (eqIdx === -1) {
+            throw new CliError(`Invalid --param format: "${pair}". Expected key=value.`, EXIT_CODES.ARGUMENT_ERROR);
+        }
+        const key = pair.slice(0, eqIdx).trim();
+        if (!key) {
+            throw new CliError(`Invalid --param format: "${pair}". Parameter name cannot be empty.`, EXIT_CODES.ARGUMENT_ERROR);
+        }
+        const raw = pair.slice(eqIdx + 1);
+        result[key] = coerceParamValue(raw);
+    }
+    return result;
+}
+function coerceParamValue(raw) {
+    const trimmed = raw.trim();
+    if (trimmed === "true") {
+        return true;
+    }
+    if (trimmed === "false") {
+        return false;
+    }
+    if (/^-?\d+$/.test(trimmed)) {
+        return Number(trimmed);
+    }
+    if (/^-?\d+\.\d+$/.test(trimmed)) {
+        return Number(trimmed);
+    }
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            throw new CliError(`Invalid JSON in --param value: ${trimmed.slice(0, 80)}${trimmed.length > 80 ? "…" : ""}`, EXIT_CODES.ARGUMENT_ERROR);
+        }
+    }
+    return raw;
+}
+async function triggerWorkflowRun(runtime, body) {
+    return request(runtime, "/workflowRuns.trigger", {
+        method: "POST",
+        body,
+    });
+}
+async function pollForWorkflowRunInfo(runtime, workflowRunId) {
+    const seenEventIds = new Set();
+    while (true) {
+        try {
+            const infoResponse = await getWorkflowRun(runtime, workflowRunId);
+            const workflowRun = infoResponse.body.workflow_run;
+            if (workflowRun.events) {
+                for (const event of workflowRun.events) {
+                    if (!seenEventIds.has(event.id)) {
+                        renderRichText([workflowRunEventContent(event), ui.blankLine()], {
+                            useStderr: true,
+                        });
+                        seenEventIds.add(event.id);
+                    }
+                }
+            }
+            if (TERMINAL_SUCCESS.has(workflowRun.status)) {
+                return workflowRun;
+            }
+            if (TERMINAL_FAILURE.has(workflowRun.status)) {
+                throw buildTerminalStatusError(workflowRun);
+            }
+            if (!PENDING_WORKFLOW_RUN_STATUSES.has(workflowRun.status)) {
+                throw new CliError(`Unexpected workflow run status: ${workflowRun.status}`, 1);
+            }
+            // progress.update(
+            //   `${ui.bold("Workflow running")} ${ui.dim(`(${workflowRunId})`)} — ${workflowRun.status}`,
+            // );
+            await sleep(POLL_INTERVAL_MS);
+        }
+        catch (error) {
+            if (error instanceof HttpError && error.status === 429) {
+                // progress.update(
+                //   `${ui.warning(ui.GLYPHS.WARNING)} Rate limited while polling ${ui.dim(`(${workflowRunId})`)}; retrying`,
+                // );
+                await sleep(POLL_INTERVAL_MS * 5);
+                continue;
+            }
+            throw error;
+        }
+    }
+}
+function buildTerminalStatusError(run) {
+    if (run.status === "FAILED") {
+        return new CliError(`Workflow run ${run.id} failed.`, 1);
+    }
+    return new CliError(`Workflow run ${run.id} ended with status ${run.status}.`, 1);
+}
+async function sleep(ms) {
+    await new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}

package/dist/commands/workflowRuns.js

@@ -3,6 +3,7 @@ import { addLinkCommand } from "./workflowRuns/addLink.js";
 import { changeStatusCommand } from "./workflowRuns/changeStatus.js";
 import { infoCommand } from "./workflowRuns/info.js";
 import { postMessageCommand } from "./workflowRuns/postMessage.js";
+import { triggerCommand } from "./workflowRuns/trigger.js";
 export function workflowRunsCommand() {
     const workflowRuns = new Command()
         .name("workflowRuns")
@@ -11,5 +12,6 @@ export function workflowRunsCommand() {
     workflowRuns.addCommand(changeStatusCommand());
     workflowRuns.addCommand(infoCommand());
     workflowRuns.addCommand(postMessageCommand());
+    workflowRuns.addCommand(triggerCommand());
     return workflowRuns;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@get-dx/cli",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "description": "DX CLI",
   "author": "DX <developers@getdx.com>",
   "bugs": {
@@ -11,6 +11,7 @@
     "dx": "dist/index.js"
   },
   "files": [
+    "assets",
     "dist"
   ],
   "homepage": "https://github.com/get-dx/cli#readme",