@get-dx/cli 0.3.2 → 0.3.4

package/dist/assets.js

@@ -0,0 +1,15 @@
+import fs from "fs";
+let assets = null;
+export function getAssets() {
+    if (assets === null) {
+        assets = {
+            logoD: loadAsset("logo-d.txt"),
+            logoX: loadAsset("logo-x.txt"),
+        };
+    }
+    return assets;
+}
+function loadAsset(filename) {
+    const filePath = new URL(`../assets/${filename}`, import.meta.url);
+    return fs.readFileSync(filePath, "utf8");
+}

package/dist/cli.js

@@ -6,6 +6,7 @@ import { scorecardsCommand } from "./commands/scorecards.js";
 import { snapshotsCommand } from "./commands/snapshots.js";
 import { studioCommand } from "./commands/studio.js";
 import { teamsCommand } from "./commands/teams.js";
+import { workflowRunsCommand } from "./commands/workflowRuns.js";
 import { workflowsCommand } from "./commands/workflows.js";
 import { handleError } from "./commandHelpers.js";
 import cliPackage from "../package.json" with { type: "json" };
@@ -40,6 +41,7 @@ function createProgram() {
     program.addCommand(snapshotsCommand());
     program.addCommand(studioCommand());
     program.addCommand(teamsCommand());
+    program.addCommand(workflowRunsCommand());
     program.addCommand(workflowsCommand());
     applyExitOverride(program);
     return program;

package/dist/commands/auth.js

@@ -3,7 +3,7 @@ import { Command } from "commander";
 import { deleteToken, setToken } from "../secrets.js";
 import { renderJson } from "../renderers.js";
 import { renderAuthInfo, renderLoggedOut } from "./authRendering.js";
-import { getContext, wrapAction } from "../commandHelpers.js";
+import { createExampleText, getContext, wrapAction, } from "../commandHelpers.js";
 import { persistBaseUrls, resolveApiBaseUrl, deriveBaseUrlsFromEnv, } from "../config.js";
 import { CliError } from "../errors.js";
 import { request } from "../http.js";
@@ -17,6 +17,20 @@ export function authCommand() {
     auth
         .command("login")
         .option("--token <token>", "Account web API token or personal access token. Omit this option to login interactively by web browser or pasting.")
+        .addHelpText("afterAll", createExampleText([
+        {
+            label: "Log in interactively via browser or by pasting a token",
+            command: "dx auth login",
+        },
+        {
+            label: "Log in non-interactively with a token",
+            command: "dx auth login --token <token>",
+        },
+        {
+            label: "Log in to a managed deployment with custom base URLs",
+            command: "DX_API_BASE_URL=https://api.dx.example.com DX_WEB_BASE_URL=https://dx.example.com dx auth login --token <token>",
+        },
+    ]))
         .action(wrapAction(async (commandOptions, command) => {
         const context = getContext(command);
         const { apiBaseUrl, webBaseUrl } = deriveBaseUrlsFromEnv();
@@ -63,7 +77,15 @@ export function authCommand() {
         }
         renderAuthInfo(response, token, apiBaseUrl);
     }));
-    auth.command("logout").action(wrapAction(async (_options, command) => {
+    auth
+        .command("logout")
+        .addHelpText("afterAll", createExampleText([
+        {
+            label: "Log out and remove the stored token",
+            command: "dx auth logout",
+        },
+    ]))
+        .action(wrapAction(async (_options, command) => {
         const context = getContext(command);
         const apiBaseUrl = resolveApiBaseUrl();
         deleteToken(apiBaseUrl);
@@ -77,6 +99,20 @@ export function authCommand() {
     auth
         .command("status")
         .alias("info")
+        .addHelpText("afterAll", createExampleText([
+        {
+            label: "Show the currently authenticated user and token details",
+            command: "dx auth status",
+        },
+        {
+            label: "Return auth details as JSON",
+            command: "dx auth status --json",
+        },
+        {
+            label: "Pipe auth details into `jq` and list scopes",
+            command: "dx auth status --json | jq --raw-output '.auth.scopes[]'",
+        },
+    ]))
         .action(wrapAction(async (_options, command) => {
         const runtime = buildRuntime(getContext(command));
         const response = await getAuthInfo(runtime);

package/dist/commands/catalog/entities.js

@@ -497,7 +497,7 @@ function parseEntityAliases(entityTypeIdentifier, rawAliases, knownAliases) {
             result[key] = [];
             continue;
         }
-        result[key] = [...(result[key] ?? []), { identifier: rawValue }];
+        result[key] = [...(result[key] ?? []), { lookup: rawValue }];
     }
     return result;
 }

package/dist/commands/init.js

@@ -8,34 +8,35 @@ import { buildLogger, buildRuntime, buildRuntimeSafe } from "../runtime.js";
 import { getAuthInfo } from "./auth.js";
 import { renderAuthInfo } from "./authRendering.js";
 import { loginViaBrowser } from "../loginViaBrowser.js";
-import { getContext } from "../commandHelpers.js";
-import { wrapAction } from "../commandHelpers.js";
+import { createExampleText, getContext, wrapAction, } from "../commandHelpers.js";
 import { renderRichText } from "../renderers.js";
 import * as ui from "../ui.js";
 import { CliError } from "../errors.js";
 import { deriveBaseUrlsFromEnv, persistBaseUrls } from "../config.js";
 import { setToken } from "../secrets.js";
-// FIXME: make this WAY more glam
-// Choose a more interesting ASCII art font from https://patorjk.com/software/taag/
-const WELCOME_BANNER = ui.indent(`\
-▄▄▄▄▄     ▄▄▄  ▄▄▄
-██▀▀▀██    ██▄▄██
-██    ██    ████
-██    ██     ██
-██    ██    ████
-██▄▄▄██    ██  ██
-▀▀▀▀▀     ▀▀▀  ▀▀▀
-`, 2);
+import { renderWelcomeAnimation } from "../welcomeAnimation.js";
 export function initCommand() {
     const init = new Command()
         .name("init")
         .description("Initialize the DX CLI")
+        .addHelpText("afterAll", createExampleText([
+        {
+            label: "Initialize the CLI",
+            command: "dx init",
+        },
+        {
+            label: "Initialize the CLI for a managed deployment with custom base URLs",
+            command: "DX_API_BASE_URL=https://api.dx.example.com DX_WEB_BASE_URL=https://dx.example.com dx init",
+        },
+    ]))
         .action(wrapAction(async (commandOptions, command) => {
         const context = getContext(command);
         let runtime = buildRuntimeSafe(context);
         ensureInteractive();
-        showWelcomeBanner();
+        await renderWelcomeAnimation();
         runtime = await ensureLoggedIn(context, runtime);
+        // Sleep for a bit to help with visual chunking
+        await sleep(500);
         await optionallySetupSkill(runtime);
         renderRichText([
             ui.blankLine(),
@@ -49,9 +50,6 @@ function ensureInteractive() {
         throw new CliError("`dx init` must be run interactively");
     }
 }
-function showWelcomeBanner() {
-    renderRichText([ui.p(ui.success(WELCOME_BANNER))]);
-}
 async function ensureLoggedIn(context, runtime) {
     renderRichText([ui.h1(`Checking if you are logged in...`), ui.blankLine()]);
     if (runtime) {
@@ -155,3 +153,6 @@ async function optionallySetupSkill(runtime) {
         throw new CliError(`Failed to setup the DX skill: ${result.stderr}`);
     }
 }
+async function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/commands/teams.js

@@ -109,7 +109,7 @@ async function getTeamInfo(runtime, lookup) {
     });
     return response.body;
 }
-async function listTeams(runtime) {
+export async function listTeams(runtime) {
     const response = await request(runtime, "/teams.list", {
         method: "GET",
     });

package/dist/commands/workflowRuns/addLink.js

@@ -0,0 +1,46 @@
+import { Command } from "commander";
+import { createExampleText, getContext, wrapAction, } from "../../commandHelpers.js";
+import { buildRuntime } from "../../runtime.js";
+import { renderJson, renderRichText } from "../../renderers.js";
+import * as ui from "../../ui.js";
+import { request } from "../../http.js";
+export function addLinkCommand() {
+    return new Command()
+        .name("addLink")
+        .description("Add a link to a workflow run")
+        .argument("<workflow-run-id>", "The ID of the workflow run")
+        .requiredOption("--url <url>", "The URL of the link")
+        .requiredOption("--label <label>", "The label of the link")
+        .addHelpText("afterAll", createExampleText([
+        {
+            label: "Add a link to a workflow run",
+            command: 'dx workflowRuns addLink hvserjgz5lo7 --url https://www.example.com --label "Example Website"',
+        },
+    ]))
+        .action(wrapAction(async (workflowRunId, options, command) => {
+        const context = getContext(command);
+        const runtime = buildRuntime(context);
+        const response = await addLink(runtime, workflowRunId, options.url, options.label);
+        if (runtime.context.json) {
+            renderJson(response);
+        }
+        else {
+            renderRichText([
+                ui.p(`${ui.success(ui.GLYPHS.CHECK)} Added link to workflow run ${ui.code(workflowRunId)}.`),
+                ui.p(`Web link: ${ui.link(ui.webLink(`/self-service/workflow-runs/${workflowRunId}`, runtime))}`),
+            ]);
+        }
+    }));
+}
+async function addLink(runtime, workflowRunId, url, label) {
+    return request(runtime, "/workflowRuns.addLink", {
+        method: "POST",
+        body: {
+            workflow_run_id: workflowRunId,
+            link: {
+                url,
+                label,
+            },
+        },
+    });
+}

package/dist/commands/workflowRuns/changeStatus.js

@@ -0,0 +1,53 @@
+import { Command } from "commander";
+import { createExampleText, getContext, wrapAction, } from "../../commandHelpers.js";
+import { buildRuntime } from "../../runtime.js";
+import { renderJson, renderRichText } from "../../renderers.js";
+import * as ui from "../../ui.js";
+import { request } from "../../http.js";
+import { CliError, EXIT_CODES } from "../../errors.js";
+export function changeStatusCommand() {
+    return new Command()
+        .name("changeStatus")
+        .description("Change the status of a workflow run")
+        .argument("<workflow-run-id>", "The ID of the workflow run")
+        .requiredOption("--status <updated-status>", "The status to change to")
+        .addHelpText("afterAll", createExampleText([
+        {
+            label: "Mark a workflow run as succeeded",
+            command: "dx workflowRuns changeStatus hvserjgz5lo7 --status SUCCEEDED",
+        },
+        {
+            label: "Mark a workflow run as failed",
+            command: "dx workflowRuns changeStatus hvserjgz5lo7 --status FAILED",
+        },
+    ]))
+        .action(wrapAction(async (workflowRunId, options, command) => {
+        const context = getContext(command);
+        const runtime = buildRuntime(context);
+        if (!isValidStatus(options.status)) {
+            throw new CliError(`Invalid status: ${options.status}. Must be one of: SUCCEEDED, FAILED.`, EXIT_CODES.ARGUMENT_ERROR);
+        }
+        const response = await changeStatus(runtime, workflowRunId, options.status);
+        if (runtime.context.json) {
+            renderJson(response);
+        }
+        else {
+            renderRichText([
+                ui.p(`${ui.success(ui.GLYPHS.CHECK)} Changed status of workflow run ${ui.code(workflowRunId)} to ${ui.code(options.status)}.`),
+                ui.p(`Web link: ${ui.link(ui.webLink(`/self-service/workflow-runs/${workflowRunId}`, runtime))}`),
+            ]);
+        }
+    }));
+}
+function isValidStatus(updatedStatus) {
+    return updatedStatus === "SUCCEEDED" || updatedStatus === "FAILED";
+}
+async function changeStatus(runtime, workflowRunId, status) {
+    return request(runtime, "/workflowRuns.changeStatus", {
+        method: "POST",
+        body: {
+            workflow_run_id: workflowRunId,
+            status,
+        },
+    });
+}

package/dist/commands/workflowRuns/events.js

@@ -0,0 +1,58 @@
+import * as ui from "../../ui.js";
+export function workflowRunEventContent(event) {
+    const ts = ui.dim(event.occurred_at);
+    const message = formatEventMessage(event);
+    return ui.p(`${ts} ${message}`, false);
+}
+function formatEventMessage(event) {
+    const userName = event.user?.name ?? event.user?.email ?? "API";
+    switch (event.type) {
+        case "WORKFLOW_TRIGGERED":
+            return `Workflow run triggered by ${ui.bold(userName)}`;
+        case "WORKFLOW_RUN_REQUESTED":
+            return `Workflow run requested by ${ui.bold(userName)}`;
+        case "APPROVERS_NOTIFIED":
+            return "Approvers notified";
+        case "APPROVAL_PERFORMED":
+            return `Approved by ${ui.bold(userName)}`;
+        case "REJECTION_PERFORMED":
+            return `Rejected by ${ui.bold(userName)}`;
+        case "HTTP_REQUEST_COMPLETED": {
+            const method = event.data?.request?.method?.toUpperCase();
+            const url = event.data?.request?.url;
+            const status = event.data?.response?.status;
+            const reqSummary = method && url ? ` ${ui.code(`${method} ${url}`)}` : "";
+            const statusSummary = status ? ` → ${ui.code(String(status))}` : "";
+            return `Sent HTTP request${reqSummary}${statusSummary}`;
+        }
+        case "POST_MESSAGE": {
+            const text = event.message ?? "";
+            const truncated = text.length > 120 ? text.slice(0, 120) + "…" : text;
+            return truncated;
+        }
+        case "ADD_LINK": {
+            const link = event.data?.link;
+            if (link) {
+                const label = link.label ? `${link.label}: ` : "";
+                return `Added link ${label}${ui.link(link.url)}`;
+            }
+            return "Added a link";
+        }
+        case "CHANGE_STATUS": {
+            const status = event.data?.status;
+            return status
+                ? `Status changed to ${ui.bold(status.toLowerCase())}`
+                : "Status changed";
+        }
+        case "WORKFLOW_SUCCEEDED":
+            return `${ui.success(ui.GLYPHS.CHECK)} Workflow run succeeded`;
+        case "WORKFLOW_FAILED":
+            return `${ui.error(ui.GLYPHS.ERROR)} Workflow run failed`;
+        case "WORKFLOW_TIMEOUT":
+            return `${ui.error(ui.GLYPHS.ERROR)} Workflow run timed out`;
+        case "WORKFLOW_CANCELLED":
+            return `${ui.warning(ui.GLYPHS.WARNING)} Workflow run cancelled by ${ui.bold(userName)}`;
+        default:
+            return `Event: ${event.type}`;
+    }
+}

package/dist/commands/workflowRuns/info.js

@@ -0,0 +1,82 @@
+import { Command } from "commander";
+import { createExampleText, getContext, wrapAction, } from "../../commandHelpers.js";
+import { buildRuntime } from "../../runtime.js";
+import { renderJson, renderRichText } from "../../renderers.js";
+import * as ui from "../../ui.js";
+import { request } from "../../http.js";
+import { workflowRunEventContent } from "./events.js";
+export function infoCommand() {
+    return new Command()
+        .name("info")
+        .description("Get info for a workflow run")
+        .argument("<workflow-run-id>", "The ID of the workflow run")
+        .addHelpText("afterAll", createExampleText([
+        {
+            label: "Get info for a workflow run",
+            command: "dx workflowRuns info hvserjgz5lo7",
+        },
+    ]))
+        .action(wrapAction(async (workflowRunId, options, command) => {
+        const context = getContext(command);
+        const runtime = buildRuntime(context);
+        const infoResponse = await getWorkflowRun(runtime, workflowRunId);
+        const workflowRun = infoResponse.body.workflow_run;
+        if (runtime.context.json) {
+            renderJson({ ok: true, workflow_run: workflowRun });
+        }
+        else {
+            renderWorkflowRunInfo(workflowRun, runtime);
+        }
+    }));
+}
+function renderWorkflowRunInfo(run, runtime) {
+    renderRichText([
+        ui.h2("Workflow run"),
+        ui.h3("Summary"),
+        ...summaryContent(run, runtime),
+        ui.h3("Events"),
+        ...eventsContent(run),
+    ]);
+}
+export function renderWorkflowRunSummary(run, runtime) {
+    renderRichText([ui.h3("Workflow run"), ...summaryContent(run, runtime)]);
+}
+function summaryContent(run, runtime) {
+    const items = [
+        ui.dli("Run ID", ui.code(run.id)),
+        ui.dli("Status", run.status),
+    ];
+    if (run.workflow) {
+        items.push(ui.dli("Workflow", `${run.workflow.name} (${ui.code(run.workflow.identifier)})`));
+        items.push(ui.dli("Web link", ui.link(ui.webLink(`/self-service/workflow-runs/${run.id}`, runtime))));
+    }
+    if (run.entity) {
+        items.push(ui.dli("Entity", `${run.entity.name} (${run.entity.identifier})`));
+    }
+    if (run.started_at) {
+        items.push(ui.dli("Started", ui.timestampSummary(run.started_at)));
+    }
+    if (run.started_at && run.completed_at) {
+        items.push(ui.dli("Completed", ui.timestampSummary(run.completed_at)));
+        items.push(ui.dli("Duration", ui.durationSummary(run.started_at, run.completed_at)));
+    }
+    if (run.links?.length) {
+        const linkSummaries = run.links.map((l) => ui.p(l.label ? `${ui.bold(l.label)} ${ui.link(l.url)}` : ui.link(l.url), false));
+        items.push(ui.dli("Links", linkSummaries));
+    }
+    return [ui.dl(items, { termWidth: 14 })];
+}
+function eventsContent(run) {
+    const items = [];
+    for (const event of run.events ?? []) {
+        items.push(workflowRunEventContent(event));
+    }
+    items.push(ui.blankLine());
+    return items;
+}
+export async function getWorkflowRun(runtime, id) {
+    return request(runtime, "/workflowRuns.info", {
+        method: "GET",
+        query: { id },
+    });
+}

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/postMessage.js

@@ -0,0 +1,46 @@
+import { Command } from "commander";
+import { createExampleText, getContext, wrapAction, } from "../../commandHelpers.js";
+import { buildRuntime } from "../../runtime.js";
+import { renderJson, renderRichText } from "../../renderers.js";
+import * as ui from "../../ui.js";
+import { request } from "../../http.js";
+export function postMessageCommand() {
+    return new Command()
+        .name("postMessage")
+        .description("Post a message to a workflow run")
+        .argument("<workflow-run-id>", "The ID of the workflow run")
+        .requiredOption("--message <message>", "The message to post")
+        .addHelpText("afterAll", createExampleText([
+        {
+            label: "Post a message to a workflow run",
+            command: 'dx workflowRuns postMessage hvserjgz5lo7 --message "Hello from the CLI"',
+        },
+        {
+            label: "Post the contents of a markdown file to a workflow run",
+            command: 'dx workflowRuns postMessage hvserjgz5lo7 --message "$(cat message.md)"',
+        },
+    ]))
+        .action(wrapAction(async (workflowRunId, options, command) => {
+        const context = getContext(command);
+        const runtime = buildRuntime(context);
+        const response = await postMessage(runtime, workflowRunId, options.message);
+        if (runtime.context.json) {
+            renderJson(response);
+        }
+        else {
+            renderRichText([
+                ui.p(`${ui.success(ui.GLYPHS.CHECK)} Posted message to workflow run ${ui.code(workflowRunId)}.`),
+                ui.p(`Web link: ${ui.link(ui.webLink(`/self-service/workflow-runs/${workflowRunId}`, runtime))}`),
+            ]);
+        }
+    }));
+}
+async function postMessage(runtime, workflowRunId, message) {
+    return request(runtime, "/workflowRuns.postMessage", {
+        method: "POST",
+        body: {
+            workflow_run_id: workflowRunId,
+            message,
+        },
+    });
+}

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

@@ -0,0 +1,17 @@
+import { Command } from "commander";
+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")
+        .description("Trigger and monitor Self-service workflow runs");
+    workflowRuns.addCommand(addLinkCommand());
+    workflowRuns.addCommand(changeStatusCommand());
+    workflowRuns.addCommand(infoCommand());
+    workflowRuns.addCommand(postMessageCommand());
+    workflowRuns.addCommand(triggerCommand());
+    return workflowRuns;
+}

package/dist/commands/workflows.js

@@ -67,7 +67,7 @@ function parseOptionalScope(value) {
     return raw;
 }
 // --- API ---
-async function listWorkflows(runtime, params) {
+export async function listWorkflows(runtime, params) {
     const query = {};
     if (params.scope !== undefined)
         query.scope = params.scope;

package/dist/ui/blocks.js

@@ -73,10 +73,12 @@ export class DescriptionListItemContainer extends AbstractBlock {
     }
     render() {
         if (!this.options) {
-            throw new Error("Options are not set");
+            throw new Error("DescriptionListItemContainer: Options are not set");
         }
-        return (pc.bold(padEnd(`${this.term}:`, this.options.termWidth)) +
-            this.detailItems.map((item) => item.render()).join("\n"));
+        const termPart = pc.bold(padEnd(`${this.term}:`, this.options.termWidth));
+        const detailText = this.detailItems.map((item) => item.render()).join("\n");
+        const padding = " ".repeat(this.options.termWidth);
+        return termPart + detailText.replace(/\n/g, `\n${padding}`);
     }
     setOptions(options) {
         this.options = options;

package/dist/ui.js

@@ -105,6 +105,16 @@ export function timestampSummary(timestamp) {
     const ts = dayjs(timestamp);
     return `${ts.fromNow()} ${dim(`(${timestamp})`)}`;
 }
+export function durationSummary(start, end) {
+    const pluralizeWithCount = (word, n) => `${n} ${word}${n === 1 ? "" : "s"}`;
+    const duration = dayjs(end).diff(dayjs(start), "seconds");
+    if (duration < 60) {
+        return pluralizeWithCount("second", duration);
+    }
+    const minutes = Math.floor(duration / 60);
+    const seconds = duration % 60;
+    return `${pluralizeWithCount("minute", minutes)}, ${pluralizeWithCount("second", seconds)}`;
+}
 // Other helpers
 export function indent(text, level) {
     return text

package/dist/welcomeAnimation.js

@@ -0,0 +1,115 @@
+import { getAssets } from "./assets.js";
+const FRAMES = 20;
+const FRAME_DELAY_MS = 100;
+const COLOR_START = [20, 20, 20];
+const COLOR_HALFWAY = [95, 89, 237]; // Indigo
+const COLOR_END = [255, 255, 255];
+const COLOR_BACKGROUND = [0, 0, 0];
+const SEQUENCE_CLEAR_SCREEN = "\x1b[2J\x1b[3J\x1b[H";
+const SEQUENCE_CURSOR_HOME = "\x1b[H";
+export async function renderWelcomeAnimation() {
+    if (process.env.DX_DISABLE_WELCOME_ANIMATION) {
+        return;
+    }
+    const assets = getAssets();
+    const LOGO_D_CONTENT = assets["logoD"];
+    const LOGO_X_CONTENT = assets["logoX"];
+    const canvasColumns = process.stdout.columns;
+    process.stderr.write(SEQUENCE_CLEAR_SCREEN);
+    await sleep(100);
+    const compositeWidth = getMaxColumns(LOGO_X_CONTENT);
+    const centeredLogoD = center(LOGO_D_CONTENT, Math.min(canvasColumns, 80), compositeWidth);
+    const centeredLogoX = center(LOGO_X_CONTENT, Math.min(canvasColumns, 80), compositeWidth);
+    for (let frame = 0; frame < FRAMES; frame += 1) {
+        const progress = frame / (FRAMES - 1);
+        const progressD = clamp(progress * 2, 0, 1);
+        const progressX = clamp((progress - 0.5) * 2, 0, 1);
+        const colorD = getThreeStageColor(progressD, COLOR_START, COLOR_HALFWAY, COLOR_END);
+        const colorX = getThreeStageColor(progressX, COLOR_START, COLOR_HALFWAY, COLOR_END);
+        const showX = progress >= 0.5;
+        process.stderr.write(SEQUENCE_CURSOR_HOME +
+            "\n\n" +
+            colorizeComposite(centeredLogoD, centeredLogoX, colorD, colorX, COLOR_BACKGROUND, showX) +
+            "\n\n\n");
+        await sleep(FRAME_DELAY_MS);
+    }
+}
+function center(text, canvasWidth, anchorWidth = getMaxColumns(text)) {
+    const maxTextWidth = Math.max(...text.split("\n").map((row) => row.length));
+    const safeCanvasWidth = Math.max(canvasWidth, anchorWidth);
+    const leftPaddingSize = Math.max(0, Math.floor((safeCanvasWidth - anchorWidth) / 2));
+    const lines = text.split("\n");
+    const centeredLines = [];
+    for (const line of lines) {
+        const leftPaddedLine = " ".repeat(leftPaddingSize) + line.padEnd(maxTextWidth);
+        const rightPadding = " ".repeat(Math.max(0, safeCanvasWidth - leftPaddedLine.length));
+        centeredLines.push(leftPaddedLine + rightPadding);
+    }
+    return centeredLines.join("\n") + "\n";
+}
+function colorizeComposite(textD, textX, colorD, colorX, colorBackground, showX) {
+    const linesD = textD.split("\n");
+    const linesX = textX.split("\n");
+    const rowCount = Math.max(linesD.length, linesX.length);
+    const [br, bg, bb] = colorBackground;
+    const background = `\x1b[48;2;${br};${bg};${bb}m`;
+    const reset = "\x1b[0m";
+    const outputLines = [];
+    for (let rowIndex = 0; rowIndex < rowCount; rowIndex += 1) {
+        const rowD = linesD[rowIndex] ?? "";
+        const rowX = linesX[rowIndex] ?? "";
+        const columnCount = Math.max(rowD.length, rowX.length);
+        let currentColor = null;
+        let rowOutput = background;
+        for (let col = 0; col < columnCount; col += 1) {
+            const charD = rowD[col] ?? " ";
+            const charX = showX ? (rowX[col] ?? " ") : " ";
+            const useX = charX !== " ";
+            const useD = !useX && charD !== " ";
+            const nextColor = useX ? colorX : useD ? colorD : null;
+            const char = useX ? charX : useD ? charD : " ";
+            if (nextColor === null) {
+                if (currentColor !== null) {
+                    rowOutput += background;
+                    currentColor = null;
+                }
+            }
+            else if (currentColor === null ||
+                currentColor[0] !== nextColor[0] ||
+                currentColor[1] !== nextColor[1] ||
+                currentColor[2] !== nextColor[2]) {
+                rowOutput += colorToAnsi(nextColor);
+                currentColor = nextColor;
+            }
+            rowOutput += char;
+        }
+        rowOutput += reset;
+        outputLines.push(rowOutput);
+    }
+    return outputLines.join("\n");
+}
+function colorToAnsi(colorForeground) {
+    const [fr, fg, fb] = colorForeground;
+    return `\x1b[38;2;${fr};${fg};${fb}m`;
+}
+function getMaxColumns(...texts) {
+    return Math.max(...texts.map((text) => Math.max(...text.split("\n").map((row) => row.length))));
+}
+function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function tweenLinear(start, end, percent) {
+    return start + (end - start) * percent;
+}
+function tweenColor(colorStart, colorEnd, percent) {
+    return colorStart.map((start, index) => Math.round(tweenLinear(start, colorEnd[index], percent)));
+}
+function getThreeStageColor(progress, colorStart, colorHalfway, colorEnd) {
+    if (progress <= 0.5) {
+        return tweenColor(colorStart, colorHalfway, progress * 2);
+    }
+    return tweenColor(colorHalfway, colorEnd, (progress - 0.5) * 2);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@get-dx/cli",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "DX CLI",
   "author": "DX <developers@getdx.com>",
   "bugs": {