@get-dx/cli 0.7.0 → 0.9.0

package/dist/cli.js

@@ -1,6 +1,8 @@
 import { Command, Option } from "commander";
+import { attributeGroupsCommand } from "./commands/attributeGroups.js";
 import { authCommand } from "./commands/auth.js";
 import { catalogCommand } from "./commands/catalog.js";
+import { doctorCommand } from "./commands/doctor.js";
 import { initCommand } from "./commands/init.js";
 import { scorecardsCommand } from "./commands/scorecards.js";
 import { snapshotsCommand } from "./commands/snapshots.js";
@@ -48,8 +50,10 @@ function createProgram() {
         .addOption(new Option("--agent <name>", "Agent name to send as an HTTP header"))
         .addOption(new Option("--agent-model <model>", "Agent model name to send as an HTTP header"))
         .addOption(new Option("--agent-session-id <id>", "Agent session ID to send as an HTTP header"));
+    program.addCommand(attributeGroupsCommand());
     program.addCommand(authCommand());
     program.addCommand(catalogCommand());
+    program.addCommand(doctorCommand());
     program.addCommand(initCommand());
     program.addCommand(scorecardsCommand());
     program.addCommand(snapshotsCommand());

package/dist/commands/attributeGroups.js

@@ -0,0 +1,100 @@
+import { Command } from "commander";
+import { createExampleText, getContext, wrapAction, } from "../commandHelpers.js";
+import { request } from "../http.js";
+import { renderJson, renderRichText } from "../renderers.js";
+import { buildRuntime } from "../runtime.js";
+import * as ui from "../ui.js";
+export function attributeGroupsCommand() {
+    const attributeGroups = new Command()
+        .name("attributeGroups")
+        .description("List attribute groups and values for filtering snapshot scores");
+    attributeGroups
+        .command("list")
+        .description("List attribute groups and their attribute values")
+        .addHelpText("afterAll", createExampleText([
+        {
+            label: "List attribute groups in human-readable output",
+            command: "dx attributeGroups list",
+        },
+        {
+            label: "Print raw JSON for automation",
+            command: "dx --json attributeGroups list",
+        },
+    ]))
+        .action(wrapAction(async (_options, command) => {
+        const runtime = await buildRuntime(getContext(command));
+        const response = await listAttributeGroups(runtime);
+        if (runtime.context.json) {
+            renderJson(response);
+        }
+        else {
+            renderAttributeGroups(response.attribute_groups);
+        }
+    }));
+    return attributeGroups;
+}
+export async function listAttributeGroups(runtime) {
+    const response = await request(runtime, "/attributeGroups.list", {
+        method: "GET",
+    });
+    return response.body;
+}
+function renderAttributeGroups(unsortedGroups) {
+    const attributeGroups = [...unsortedGroups].sort(byPosition);
+    const blocks = [ui.h1("Attribute Groups")];
+    blocks.push(ui.p(`Displaying ${ui.bold(attributeGroups.length.toString())} attribute groups.`));
+    if (attributeGroups.length === 0) {
+        blocks.push(ui.p("No attribute groups are available for this account. Create or sync attribute groups in DX before filtering snapshot scores by attribute."));
+        renderRichText(blocks);
+        return;
+    }
+    for (const attributeGroup of attributeGroups) {
+        blocks.push(ui.h2(`${attributeGroup.name} (${ui.code(attributeGroup.id)})`));
+        blocks.push(ui.dl([
+            ui.dli("Type", formatAttributeGroupType(attributeGroup.type)),
+            ui.dli("ID", ui.code(attributeGroup.id)),
+            ...(attributeGroup.position === null
+                ? []
+                : [ui.dli("Position", attributeGroup.position.toString())]),
+            ...(attributeGroup.hidden ? [ui.dli("Hidden", "Yes")] : []),
+            // The API only returns privileged groups the user can see.
+            ...(attributeGroup.privileged ? [ui.dli("Privileged", "Yes")] : []),
+        ], { termWidth: 12 }));
+        if (attributeGroup.attributes.length === 0) {
+            blocks.push(ui.p(`Attributes: ${ui.dim("(None)")}`));
+            continue;
+        }
+        blocks.push(ui.p("Attributes:"));
+        blocks.push(ui.ul([...attributeGroup.attributes]
+            .sort(byPositionThenName)
+            .map((attribute) => ui.li(`${attribute.name} (${ui.code(attribute.id)})`))));
+    }
+    renderRichText(blocks);
+}
+// Items without a position sort last. Ties keep the API's order (a stable
+// sort), which is by id for groups.
+function byPosition(a, b) {
+    if (a.position === b.position)
+        return 0;
+    if (a.position === null)
+        return 1;
+    if (b.position === null)
+        return -1;
+    return a.position - b.position;
+}
+// Attributes are ordered by position, then name.
+function byPositionThenName(a, b) {
+    return byPosition(a, b) || a.name.localeCompare(b.name);
+}
+function formatAttributeGroupType(type) {
+    switch (type.toUpperCase()) {
+        case "ADMIN_MANAGED":
+            return "Admin managed";
+        case "SELF_REPORTED":
+            return "Self reported";
+        case "DX_MANAGED":
+            return "DX managed";
+        default:
+            return type;
+    }
+}

package/dist/commands/auth.js

@@ -154,8 +154,9 @@ export function authCommand() {
     return auth;
 }
 // TODO: should we move this somewhere more central, since `init` needs it?
-export async function getAuthInfo(runtime) {
+export async function getAuthInfo(runtime, options) {
     const response = await request(runtime, "/auth.info", {
+        ...options,
         method: "GET",
     });
     return response.body;

package/dist/commands/catalog/entityTypes.js

@@ -14,9 +14,9 @@ export function entityTypesCommand() {
         .description("Manage catalog entity types");
     entityTypes
         .command("create")
-        .description("Create a new entity type from a YAML file or stdin. The `init` command can be used to generate a starting template.")
-        .option("--from-file <path>", "Read a YAML file and create an entity type from its contents")
-        .option("--from-stdin", "Read YAML from stdin and create an entity type from its contents")
+        .description("Create a new entity type from a YAML or JSON file or stdin. The `init` command can be used to generate a starting template.")
+        .option("--from-file <path>", "Read a YAML or JSON file and create an entity type from its contents")
+        .option("--from-stdin", "Read YAML or JSON from stdin and create an entity type from its contents")
         .addHelpText("afterAll", createExampleText([
         {
             label: "Generate a blank template first",
@@ -205,10 +205,10 @@ export function entityTypesCommand() {
     }));
     entityTypes
         .command("update")
-        .description("Update an existing entity type from a YAML file or stdin. The `init` command can be used to initialize the entity type file.")
+        .description("Update an existing entity type from a YAML or JSON file or stdin. The `init` command can be used to initialize the entity type file.")
         .argument("<identifier>", "The unique identifier of the entity type")
-        .option("--from-file <path>", "Read a YAML file and update the entity type with its contents")
-        .option("--from-stdin", "Read YAML from stdin and update the entity type with its contents")
+        .option("--from-file <path>", "Read a YAML or JSON file and update the entity type with its contents")
+        .option("--from-stdin", "Read YAML or JSON from stdin and update the entity type with its contents")
         .addHelpText("afterAll", createExampleText([
         {
             label: "Initialize a file first",

package/dist/commands/doctor.js

@@ -0,0 +1,85 @@
+import { Command } from "commander";
+import { createExampleText, getContext, wrapAction, } from "../commandHelpers.js";
+import { runDoctor } from "../doctor/index.js";
+import { AsyncProgressReporter, renderJson, renderRichText, } from "../renderers.js";
+import * as ui from "../ui.js";
+const MIN_LABEL_WIDTH = 26;
+const PHASE_MESSAGES = {
+    config: "Checking configuration…",
+    network: "Checking network…",
+    auth: "Checking authentication…",
+    version: "Checking for updates…",
+};
+export function doctorCommand() {
+    return new Command("doctor")
+        .description("Diagnose problems with your CLI instance's installation, configuration, networking, and authentication")
+        .addHelpText("afterAll", createExampleText([
+        { label: "Check your setup", command: "dx doctor" },
+        { label: "Print the report as JSON", command: "dx doctor --json" },
+    ]))
+        .action(wrapAction(async (_options, command) => {
+        const context = getContext(command);
+        const progress = new AsyncProgressReporter();
+        progress.start(PHASE_MESSAGES.config);
+        let report;
+        try {
+            report = await runDoctor(context, {
+                onPhase: (phase) => progress.update(PHASE_MESSAGES[phase]),
+            });
+        }
+        finally {
+            progress.stop();
+        }
+        if (context.json) {
+            renderJson(report);
+        }
+        else {
+            renderDoctorReport(report);
+        }
+        if (!report.ok) {
+            process.exitCode = 1;
+        }
+    }));
+}
+export function renderDoctorReport(report) {
+    const labelWidth = Math.max(MIN_LABEL_WIDTH, ...report.sections.flatMap((section) => section.checks.map((check) => check.label.length + 2)));
+    renderRichText([
+        ...report.sections.map((section) => ui.statusList(section.title, section.checks.map((check) => ({
+            status: check.status,
+            label: check.label,
+            detail: formatDetail(check),
+            hint: check.hint,
+        })), { labelWidth })),
+        ui.p(summaryLine(report)),
+    ]);
+}
+function formatDetail(check) {
+    if (!check.source) {
+        return check.message;
+    }
+    return `${check.message} ${ui.dim(`[from ${sourceName(check.source)}]`)}`;
+}
+function sourceName(source) {
+    switch (source) {
+        case "env":
+            return "env";
+        case "config":
+            return "config file";
+        case "default":
+            return "default";
+        case "keychain":
+            return "keychain";
+    }
+}
+function summaryLine(report) {
+    const { fail, warn } = report.summary;
+    const plural = (count, word) => `${count} ${word}${count === 1 ? "" : "s"}`;
+    if (fail > 0) {
+        const failed = ui.error(`${plural(fail, "check")} failed`);
+        return warn > 0 ? `${failed}, ${plural(warn, "warning")}.` : `${failed}.`;
+    }
+    if (warn > 0) {
+        return ui.warning(`All required checks passed, ${plural(warn, "warning")}.`);
+    }
+    return ui.success("All checks passed.");
+}

package/dist/commands/scorecards.js

@@ -14,9 +14,9 @@ export function scorecardsCommand() {
         .description("Manage scorecards");
     scorecards
         .command("create")
-        .description("Create a new scorecard from a YAML file or stdin. The `init` command can be used to generate a starting template.")
-        .option("--from-file <path>", "Read a YAML file and create a scorecard from its contents")
-        .option("--from-stdin", "Read YAML from stdin and create a scorecard from its contents")
+        .description("Create a new scorecard from a YAML or JSON file or stdin. The `init` command can be used to generate a starting template.")
+        .option("--from-file <path>", "Read a YAML or JSON file and create a scorecard from its contents")
+        .option("--from-stdin", "Read YAML or JSON from stdin and create a scorecard from its contents")
         .addHelpText("afterAll", createExampleText([
         {
             label: "Generate a blank template first",
@@ -216,10 +216,10 @@ export function scorecardsCommand() {
     }));
     scorecards
         .command("update")
-        .description("Update an existing scorecard from a YAML file or stdin. The `init` command can be used to initialize the scorecard file.")
+        .description("Update an existing scorecard from a YAML or JSON file or stdin. The `init` command can be used to initialize the scorecard file.")
         .argument("<id>", "The unique ID of the scorecard")
-        .option("--from-file <path>", "Read a YAML file and update the scorecard with its contents")
-        .option("--from-stdin", "Read YAML from stdin and update the scorecard with its contents")
+        .option("--from-file <path>", "Read a YAML or JSON file and update the scorecard with its contents")
+        .option("--from-stdin", "Read YAML or JSON from stdin and update the scorecard with its contents")
         .addHelpText("afterAll", createExampleText([
         {
             label: "Initialize a file first",

package/dist/commands/snapshots.js

@@ -4,6 +4,7 @@ import { CliError, EXIT_CODES } from "../errors.js";
 import { request } from "../http.js";
 import { renderJson, renderRichText } from "../renderers.js";
 import { buildRuntime } from "../runtime.js";
+import { formatTeamMember } from "./teams.js";
 import * as ui from "../ui.js";
 export function snapshotsCommand() {
     const snapshots = new Command()
@@ -135,6 +136,35 @@ export function snapshotsCommand() {
             renderSnapshots(response.snapshots, runtime);
         }
     }));
+    const snapshotTeams = new Command()
+        .name("snapshotTeams")
+        .description("Work with snapshot teams");
+    snapshotTeams
+        .command("list")
+        .description("List teams for a snapshot")
+        .option("--id <id>", "The unique ID of the snapshot")
+        .addHelpText("afterAll", createExampleText([
+        {
+            label: "List teams for a snapshot",
+            command: "dx snapshots snapshotTeams list --id MjUyNbaY",
+        },
+        {
+            label: "List snapshot teams as JSON",
+            command: "dx --json snapshots snapshotTeams list --id MjUyNbaY",
+        },
+    ]))
+        .action(wrapAction(async (options, command) => {
+        const snapshotId = parseRequiredTextOption(options.id, "--id");
+        const runtime = await buildRuntime(getContext(command));
+        const response = await listSnapshotTeams(runtime, snapshotId);
+        if (runtime.context.json) {
+            renderJson(response);
+        }
+        else {
+            renderSnapshotTeams(response.snapshot_teams, snapshotId, runtime);
+        }
+    }));
+    snapshots.addCommand(snapshotTeams);
     return snapshots;
 }
 async function listSnapshotDriverComments(runtime, options) {
@@ -159,6 +189,13 @@ async function listSnapshotCsatComments(runtime, options) {
     });
     return response.body;
 }
+async function listSnapshotTeams(runtime, snapshotId) {
+    const response = await request(runtime, "/snapshots.snapshotTeams.list", {
+        method: "GET",
+        query: { snapshot_id: snapshotId },
+    });
+    return response.body;
+}
 async function getSnapshotInfo(runtime, snapshotId) {
     const response = await request(runtime, "/snapshots.info", {
         method: "GET",
@@ -237,6 +274,22 @@ function renderSnapshotCsatComments(comments, nextCursor, snapshotId, runtime) {
     }
     renderRichText(blocks);
 }
+function renderSnapshotTeams(teams, snapshotId, runtime) {
+    const blocks = [ui.h1("Snapshot Teams")];
+    blocks.push(ui.p(`Displaying ${ui.bold(teams.length.toString())} teams.`));
+    blocks.push(ui.p(`Snapshot Team IDs are only valid within this snapshot and feed ${ui.code("snapshot_team_ids")} score filters. Use ${ui.code("team_id")} with ${ui.code("dx teams info --team-id")}.`));
+    blocks.push(ui.p(ui.link(snapshotWebLink(snapshotId, "drivers", runtime))));
+    if (teams.length === 0) {
+        blocks.push(ui.p(ui.dim("(None)")));
+        renderRichText(blocks);
+        return;
+    }
+    const rootTeams = buildSnapshotTeamTree(teams);
+    rootTeams.forEach((rootTeam) => {
+        appendSnapshotTeamBlock(blocks, rootTeam, 0);
+    });
+    renderRichText(blocks);
+}
 function renderSnapshotInfo(snapshot, snapshotId, runtime) {
     const teamScores = snapshot.team_scores ?? [];
     const blocks = [ui.h1("Snapshot Information")];
@@ -298,6 +351,69 @@ function extractCsatComments(response) {
         response.comments ??
         []);
 }
+class SnapshotTeamTreeNode {
+    team;
+    children = [];
+    constructor(team) {
+        this.team = team;
+    }
+}
+function buildSnapshotTeamTree(teams) {
+    const nodes = new Map();
+    teams.forEach((team) => {
+        nodes.set(team.id, new SnapshotTeamTreeNode(team));
+    });
+    const rootTeams = [];
+    teams.forEach((team) => {
+        const currentNode = nodes.get(team.id);
+        if (currentNode.team.parent_id === null) {
+            // It's a top-level root node
+            rootTeams.push(currentNode);
+        }
+        else {
+            // Append it to its parent's children array
+            nodes.get(currentNode.team.parent_id).children.push(currentNode);
+        }
+    });
+    const sortNodes = (items) => {
+        items.sort((left, right) => compareSnapshotTeams(left.team, right.team));
+        for (const item of items) {
+            sortNodes(item.children);
+        }
+    };
+    sortNodes(rootTeams);
+    return rootTeams;
+}
+function compareSnapshotTeams(left, right) {
+    const leftName = left.name.toLocaleLowerCase();
+    const rightName = right.name.toLocaleLowerCase();
+    if (leftName !== rightName) {
+        return leftName.localeCompare(rightName);
+    }
+    // If the names are the same, compare the IDs
+    const leftId = left.id.toLocaleLowerCase();
+    const rightId = right.id.toLocaleLowerCase();
+    return leftId.localeCompare(rightId);
+}
+function appendSnapshotTeamBlock(blocks, node, depth) {
+    blocks.push(depth === 0
+        ? ui.h2(node.team.name)
+        : ui.h3(`${"↳".repeat(depth)} ${node.team.name}`));
+    const details = [
+        optionalDetail("Snapshot Team ID", formatText(node.team.id), node.team.id),
+        optionalDetail("Team ID", formatText(node.team.team_id), node.team.team_id),
+        // Match `dx teams info`: show "(None)" when the API returns a null manager,
+        // omit the row only when the field is absent entirely.
+        ui.dli("Manager", formatTeamMember(node.team.manager)),
+        optionalDetail("Parent ID", formatText(node.team.parent_id), node.team.parent_id),
+    ].filter((detail) => detail !== null);
+    if (details.length > 0) {
+        blocks.push(ui.dl(details, { termWidth: 18 }));
+    }
+    node.children.forEach((child) => {
+        appendSnapshotTeamBlock(blocks, child, depth + 1);
+    });
+}
 function formatCommentHeading(comment) {
     const heading = comment.item_name ??
         comment.driver_name ??

package/dist/commands/studio/reports.js

@@ -17,9 +17,9 @@ export function reportsCommand() {
         .description("Manage Data Studio reports");
     reports
         .command("create")
-        .description("Create a Data Studio report from a YAML file or stdin")
-        .option("--from-file <path>", "Read a YAML file and create a report from its contents")
-        .option("--from-stdin", "Read YAML from stdin and create a report from its contents")
+        .description("Create a Data Studio report from a YAML or JSON file or stdin")
+        .option("--from-file <path>", "Read a YAML or JSON file and create a report from its contents")
+        .option("--from-stdin", "Read YAML or JSON from stdin and create a report from its contents")
         .addHelpText("afterAll", createNoteText(VARIABLES_NOTE_TEXT))
         .addHelpText("afterAll", createExampleText([
         {
@@ -175,10 +175,10 @@ export function reportsCommand() {
     }));
     reports
         .command("update")
-        .description("Update a Data Studio report from a YAML file or stdin. The `init` command can be used to initialize the report file.")
+        .description("Update a Data Studio report from a YAML or JSON file or stdin. The `init` command can be used to initialize the report file.")
         .argument("<id>", "Studio report ID")
-        .option("--from-file <path>", "Read a YAML file and update the report with its contents")
-        .option("--from-stdin", "Read YAML from stdin and update the report with its contents")
+        .option("--from-file <path>", "Read a YAML or JSON file and update the report with its contents")
+        .option("--from-stdin", "Read YAML or JSON from stdin and update the report with its contents")
         .addHelpText("afterAll", createNoteText(VARIABLES_NOTE_TEXT))
         .addHelpText("afterAll", createExampleText([
         {

package/dist/commands/teams.js

@@ -200,7 +200,7 @@ function formatTeamHeading(team) {
     }
     return null;
 }
-function formatTeamMember(member) {
+export function formatTeamMember(member) {
     if (!member) {
         return ui.dim("(None)");
     }

package/dist/commands/workflow-blank-template.yaml

@@ -0,0 +1,78 @@
+# Self-service workflow configuration
+#
+# Edit this file, then run:
+#
+# ```
+# dx workflows create --from-file <path>
+# ```
+
+# Unique per account. Letters, numbers, ".", "_" and "-" only; "new" is reserved.
+identifier: ""
+name: ""
+description: ""
+# icon: globe
+color: "#38bdf8"
+
+# scope: "GLOBAL" (not tied to a catalog entity) or "ENTITY" (run against an entity)
+scope: GLOBAL
+
+# execution_type: "SIMPLE" or "EVENT_DRIVEN"
+execution_type: SIMPLE
+
+# Who can trigger a run:
+#   ANY       - all users, no approval
+#   APPROVAL  - all users, but an approver must accept (set approver_user_ids)
+#   RUNNERS   - only selected users and teams (set runners)
+#   ENTITY    - only owners of the entity (requires scope: ENTITY)
+trigger_type: ANY
+# approver_user_ids: ["<active user id>"]   # at least one when APPROVAL
+# runners:                                  # at least one when RUNNERS
+#   - user_id: "<user id>"                  # each runner sets exactly one of
+#   - squad_id: "<team id>"                 # user_id or squad_id
+#     squad_linkage_id: null                # optional
+
+# Which entities the workflow can run against (only used when scope is ENTITY).
+# entity_filter_type: "ENTITY_TYPES" or "SQL"
+entity_filter_type: ENTITY_TYPES
+# Entity type identifiers (when entity_filter_type is "ENTITY_TYPES"; at least
+# one is required when scope is ENTITY)
+entity_filter_type_identifiers: []
+# SQL filter expression (required when scope is ENTITY and entity_filter_type is "SQL")
+# entity_filter_sql: ""
+
+# The HTTP request sent when the workflow runs.
+# The url, body, header values and form_data values can use variables:
+#   {{run.id}}, {{workflow.identifier}}, {{workflow.name}},
+#   {{triggered_by_user.id}}, {{triggered_by_user.name}}, {{triggered_by_user.email}},
+#   {{triggered_by_user.team_id}}, {{triggered_by_user.team_name}},
+#   {{entity.identifier}}, {{entity.name}} (scope: ENTITY only),
+#   {{data.<parameter identifier>}}, {{secret.<name>}}
+http_request:
+  # method: GET, POST, PUT, PATCH or DELETE
+  method: POST
+  url: "https://example.com/hooks/my-workflow"
+  headers:
+    Content-Type: application/json
+  # A string or null. Must be null when form_data is used.
+  body: |-
+    {"run_id": "{{run.id}}"}
+  # form_data:
+  #   - key: example
+  #     value: "{{data.example}}"
+
+# Inputs collected from the user when triggering a run. Each parameter needs an
+# identifier (letters, numbers, underscores), a name, a type and is_required.
+parameters: []
+# parameters:
+#   - identifier: environment
+#     name: Environment
+#     description: ""
+#     # type: STRING, INTEGER, FLOAT, BOOLEAN, SELECT, USER, TEAM, EMAIL or COMPUTED
+#     type: SELECT
+#     is_required: true
+#     default_value: staging
+#     # SELECT: {options: [...]}   COMPUTED: {sql: "..."}   other types: omit
+#     definition:
+#       options:
+#         - staging
+#         - production