@get-dx/cli 0.3.1 → 0.3.3

package/README.md

@@ -18,6 +18,13 @@ Interactively login and install the AI agent skill:
 dx init
 ```
 
+For CI, Docker/dev containers, or other headless environments, pass the token
+through the environment instead of storing it in the OS credential store:
+
+```shell
+DX_API_TOKEN="$DX_TOKEN" dx auth status
+```
+
 Show help text:
 
 ```shell
@@ -42,8 +49,8 @@ Set the env vars once when initializing:
 # Interactive login
 DX_WEB_BASE_URL="https://mycompany.getdx.io" DX_API_BASE_URL="https://api.mycompany.getdx.io" dx init
 
-# Non-interactive login for CI or remote agents
-DX_WEB_BASE_URL="https://mycompany.getdx.io" DX_API_BASE_URL="https://api.mycompany.getdx.io" dx auth login --token $DX_TOKEN
+# Non-interactive use for CI, containers, or remote agents
+DX_WEB_BASE_URL="https://mycompany.getdx.io" DX_API_BASE_URL="https://api.mycompany.getdx.io" DX_API_TOKEN="$DX_TOKEN" dx auth status
 ```
 
 #### For managed deployments
@@ -54,8 +61,8 @@ Set the env vars once when initializing:
 # Interactive login
 DX_WEB_BASE_URL="https://dx.some-example-subdomain.example.com" DX_API_BASE_URL="https://api.dx.some-example-subdomain.example.com" dx init
 
-# Non-interactive login for CI or remote agents
-DX_WEB_BASE_URL="https://dx.some-example-subdomain.example.com" DX_API_BASE_URL="https://api.dx.some-example-subdomain.example.com" dx auth login --token $DX_TOKEN
+# Non-interactive use for CI, containers, or remote agents
+DX_WEB_BASE_URL="https://dx.some-example-subdomain.example.com" DX_API_BASE_URL="https://api.dx.some-example-subdomain.example.com" DX_API_TOKEN="$DX_TOKEN" dx auth status
 ```
 
 ## Logging

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

@@ -3,6 +3,7 @@ import { CliError } from "./errors.js";
 export class AuthCodeCallbackServer {
     server = null;
     address = null;
+    requestReceived = false;
     async start() {
         await new Promise((resolve, reject) => {
             const srv = createServer();
@@ -23,19 +24,34 @@ export class AuthCodeCallbackServer {
     }
     async listenForCode(onCodeReceipt) {
         return new Promise((resolve, reject) => {
-            if (!this.server) {
+            const srv = this.server;
+            if (!srv) {
                 reject(new Error("Unreachable: server not started"));
                 return;
             }
-            this.server.on("request", async (req, res) => {
-                this.stop();
+            srv.on("request", async (req, res) => {
+                if (this.requestReceived) {
+                    res.writeHead(409, { Connection: "close" }).end();
+                    return;
+                }
+                this.requestReceived = true;
                 const url = new URL(req.url ?? "/", this.address);
                 const code = url.searchParams.get("code");
                 const state = url.searchParams.get("state");
+                const stopServerAndResolve = (result) => {
+                    res.once("close", () => {
+                        this.stop();
+                        resolve(result);
+                    });
+                };
                 if (!code) {
                     const message = "Authentication failed: no code received";
-                    res.writeHead(500, { "Content-Type": "text/plain" }).end(message);
-                    resolve({ type: "ERROR", error: new CliError(message) });
+                    res.writeHead(500, {
+                        Connection: "close",
+                        "Content-Type": "text/plain",
+                    });
+                    stopServerAndResolve({ type: "ERROR", error: new CliError(message) });
+                    res.end(message);
                     return;
                 }
                 let result;
@@ -46,34 +62,52 @@ export class AuthCodeCallbackServer {
                     const message = err instanceof Error
                         ? err.message
                         : "Authentication failed: unknown error";
-                    res.writeHead(500, { "Content-Type": "text/plain" }).end(message);
-                    resolve({
+                    res.writeHead(500, {
+                        Connection: "close",
+                        "Content-Type": "text/plain",
+                    });
+                    stopServerAndResolve({
                         type: "ERROR",
                         error: err instanceof Error ? err : new CliError(message),
                     });
+                    res.end(message);
                     return;
                 }
                 if (result.type === "SUCCESS") {
                     if (result.redirectUri) {
-                        res.writeHead(302, { Location: result.redirectUri }).end();
+                        res.writeHead(302, {
+                            Connection: "close",
+                            Location: result.redirectUri,
+                        });
+                        stopServerAndResolve(result);
+                        res.end();
                     }
                     else {
-                        res
-                            .writeHead(200, { "Content-Type": "text/plain" })
-                            .end("Authentication successful");
+                        res.writeHead(200, {
+                            Connection: "close",
+                            "Content-Type": "text/plain",
+                        });
+                        stopServerAndResolve(result);
+                        res.end("Authentication successful");
                     }
                 }
                 else {
-                    res
-                        .writeHead(500, { "Content-Type": "text/plain" })
-                        .end(result.error.message);
+                    res.writeHead(500, {
+                        Connection: "close",
+                        "Content-Type": "text/plain",
+                    });
+                    stopServerAndResolve(result);
+                    res.end(result.error.message);
                 }
-                resolve(result);
             });
         });
     }
     stop() {
-        this.server?.close();
+        const srv = this.server;
+        if (!srv)
+            return;
+        srv.closeAllConnections();
+        srv.close();
         this.server = null;
     }
 }

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

@@ -0,0 +1,15 @@
+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";
+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());
+    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/secrets.js

@@ -40,16 +40,28 @@ function macosSecretStore() {
             }
         },
         set(baseUrl, token) {
-            execaSync("security", [
-                "add-generic-password",
-                "-U",
-                "-s",
-                SERVICE,
-                "-a",
-                baseUrl,
-                "-w",
-                token,
-            ]);
+            try {
+                execaSync("security", [
+                    "add-generic-password",
+                    "-U",
+                    "-s",
+                    SERVICE,
+                    "-a",
+                    baseUrl,
+                    "-w",
+                    token,
+                ]);
+            }
+            catch (error) {
+                throw new CliError([
+                    "Unable to save the DX API token securely using macOS Keychain.",
+                    "",
+                    "Set DX_API_TOKEN in the environment, or try again from a macOS session with Keychain access.",
+                    formatErrorDetails(error),
+                ]
+                    .filter(Boolean)
+                    .join("\n"));
+            }
         },
         delete(baseUrl) {
             try {
@@ -84,10 +96,78 @@ function linuxSecretStore() {
             }
         },
         set(baseUrl, token) {
-            execaSync("secret-tool", ["store", "--label=dx-cli", "service", SERVICE, "account", baseUrl], { input: token });
+            try {
+                execaSync("secret-tool", ["store", "--label=dx-cli", "service", SERVICE, "account", baseUrl], { input: token });
+            }
+            catch (error) {
+                throw buildLinuxTokenStorageError(error);
+            }
         },
         delete(_baseUrl) {
             throw new CliError("Linux token deletion is not supported by secret-tool in this implementation");
         },
     };
 }
+function buildLinuxTokenStorageError(error) {
+    if (hasErrorCode(error, "ENOENT")) {
+        return new CliError([
+            "Unable to save the DX API token securely because `secret-tool` is not installed.",
+            "",
+            "Install `libsecret-tools`, or set DX_API_TOKEN in the environment instead of using `dx auth login` or `dx init` to store credentials.",
+        ].join("\n"));
+    }
+    if (isLinuxSecretServiceUnavailable(error)) {
+        return new CliError([
+            "Unable to save the DX API token securely because the Linux Secret Service/keyring is not available.",
+            "",
+            "This often happens in Docker or dev containers, even when `secret-tool` is installed. Set DX_API_TOKEN in the container environment instead of using `dx auth login` or `dx init` to store credentials, or run the CLI in an environment with a working Secret Service provider such as GNOME Keyring.",
+            formatErrorDetails(error),
+        ]
+            .filter(Boolean)
+            .join("\n"));
+    }
+    return new CliError([
+        "Unable to save the DX API token securely using `secret-tool`.",
+        "",
+        "Set DX_API_TOKEN in the environment, or configure a working Linux Secret Service provider such as GNOME Keyring.",
+        formatErrorDetails(error),
+    ]
+        .filter(Boolean)
+        .join("\n"));
+}
+function hasErrorCode(error, code) {
+    if (!isRecord(error)) {
+        return false;
+    }
+    return error.code === code;
+}
+function isLinuxSecretServiceUnavailable(error) {
+    const text = errorText(error);
+    return [
+        "org.freedesktop.secrets",
+        "Cannot autolaunch D-Bus",
+        "No such secret service",
+    ].some((message) => text.includes(message));
+}
+function formatErrorDetails(error) {
+    if (!isRecord(error) || typeof error.stderr !== "string") {
+        return null;
+    }
+    const stderr = error.stderr.trim();
+    return stderr ? `Details: ${stderr}` : null;
+}
+function errorText(error) {
+    if (!isRecord(error)) {
+        return String(error);
+    }
+    return [
+        typeof error.stderr === "string" ? error.stderr : null,
+        typeof error.shortMessage === "string" ? error.shortMessage : null,
+        typeof error.message === "string" ? error.message : null,
+    ]
+        .filter(Boolean)
+        .join("\n");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}

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.1",
+  "version": "0.3.3",
   "description": "DX CLI",
   "author": "DX <developers@getdx.com>",
   "bugs": {