Commands: workflowRuns info and event creation

src/cli.ts

@@ -7,6 +7,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";
 
@@ -54,6 +55,7 @@ function createProgram(): Command {
   program.addCommand(snapshotsCommand());
   program.addCommand(studioCommand());
   program.addCommand(teamsCommand());
+  program.addCommand(workflowRunsCommand());
   program.addCommand(workflowsCommand());
 
   applyExitOverride(program);

src/commands/teams.ts

@@ -214,7 +214,7 @@ async function getTeamInfo(
   return response.body;
 }
 
-async function listTeams(runtime: Runtime): Promise<ListTeamsResponse> {
+export async function listTeams(runtime: Runtime): Promise<ListTeamsResponse> {
   const response = await request<ListTeamsResponse>(runtime, "/teams.list", {
     method: "GET",
   });

src/commands/workflowRuns.ts

@@ -0,0 +1,19 @@
+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(): Command {
+  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;
+}

src/commands/workflowRuns/addLink.ts

@@ -0,0 +1,79 @@
+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 { Runtime } from "../../types.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: string, 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))}`,
+            ),
+          ]);
+        }
+      }),
+    );
+}
+
+type AddLinkResponse = {
+  ok: true;
+};
+
+async function addLink(
+  runtime: Runtime,
+  workflowRunId: string,
+  url: string,
+  label: string,
+): Promise<{ body: AddLinkResponse }> {
+  return request<AddLinkResponse>(runtime, "/workflowRuns.addLink", {
+    method: "POST",
+    body: {
+      workflow_run_id: workflowRunId,
+      link: {
+        url,
+        label,
+      },
+    },
+  });
+}

src/commands/workflowRuns/changeStatus.ts

@@ -0,0 +1,93 @@
+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 { Runtime } from "../../types.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: string, 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: string,
+): updatedStatus is WorkflowRunStatus {
+  return updatedStatus === "SUCCEEDED" || updatedStatus === "FAILED";
+}
+
+type WorkflowRunStatus = "SUCCEEDED" | "FAILED";
+
+type ChangeStatusResponse = {
+  ok: true;
+};
+
+async function changeStatus(
+  runtime: Runtime,
+  workflowRunId: string,
+  status: WorkflowRunStatus,
+): Promise<{ body: ChangeStatusResponse }> {
+  return request<ChangeStatusResponse>(runtime, "/workflowRuns.changeStatus", {
+    method: "POST",
+    body: {
+      workflow_run_id: workflowRunId,
+      status,
+    },
+  });
+}

src/commands/workflowRuns/events.ts

@@ -0,0 +1,75 @@
+import { WorkflowRunEvent } from "./info.js";
+import * as ui from "../../ui.js";
+
+export function workflowRunEventContent(event: WorkflowRunEvent): ui.Block {
+  const ts = ui.dim(event.occurred_at);
+  const message = formatEventMessage(event);
+  return ui.p(`${ts} ${message}`, false);
+}
+
+function formatEventMessage(event: WorkflowRunEvent): string {
+  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 as WorkflowRunEvent).type}`;
+  }
+}