@get-dx/cli 0.2.0 → 0.3.0

package/dist/commands/init.js

@@ -1,10 +1,10 @@
 import { access } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { input, password, confirm, select } from "@inquirer/prompts";
+import { password, confirm, select } from "@inquirer/prompts";
 import { Command } from "commander";
 import { execa } from "execa";
-import { buildRuntime, buildRuntimeSafe } from "../runtime.js";
+import { buildLogger, buildRuntime, buildRuntimeSafe } from "../runtime.js";
 import { getAuthInfo } from "./auth.js";
 import { renderAuthInfo } from "./authRendering.js";
 import { loginViaBrowser } from "../loginViaBrowser.js";
@@ -13,29 +13,8 @@ import { wrapAction } from "../commandHelpers.js";
 import { renderRichText } from "../renderers.js";
 import * as ui from "../ui.js";
 import { CliError } from "../errors.js";
-import { persistBaseUrl } from "../config.js";
+import { deriveBaseUrlsFromEnv, persistBaseUrls } from "../config.js";
 import { setToken } from "../secrets.js";
-function parseHostname(raw) {
-    const normalized = raw.trim().replace(/\/$/, "");
-    if (!normalized || normalized === "app.getdx.com") {
-        return { type: "cloud" };
-    }
-    try {
-        const url = new URL(normalized.startsWith("http") ? normalized : `https://${normalized}`);
-        const host = url.hostname;
-        const dedicatedMatch = host.match(/^(.+)\.getdx\.io$/);
-        if (dedicatedMatch) {
-            return { type: "dedicated", accountName: dedicatedMatch[1] };
-        }
-        if (host) {
-            return { type: "managed", uiBaseUrl: url.origin };
-        }
-    }
-    catch {
-        // fall through to invalid
-    }
-    return { type: "invalid" };
-}
 // FIXME: make this WAY more glam
 // Choose a more interesting ASCII art font from https://patorjk.com/software/taag/
 const WELCOME_BANNER = ui.indent(`\
@@ -51,14 +30,12 @@ export function initCommand() {
     const init = new Command()
         .name("init")
         .description("Initialize the DX CLI")
-        .option("--host <hostname>", "DX hostname for dedicated or managed deployments (e.g. mycompany.getdx.io)")
         .action(wrapAction(async (commandOptions, command) => {
         const context = getContext(command);
         let runtime = buildRuntimeSafe(context);
         ensureInteractive();
         showWelcomeBanner();
-        const host = commandOptions.host || process.env.DX_HOST;
-        runtime = await ensureLoggedIn(runtime, host);
+        runtime = await ensureLoggedIn(context, runtime);
         await optionallySetupSkill(runtime);
         renderRichText([
             ui.blankLine(),
@@ -75,7 +52,7 @@ function ensureInteractive() {
 function showWelcomeBanner() {
     renderRichText([ui.p(ui.success(WELCOME_BANNER))]);
 }
-async function ensureLoggedIn(runtime, host) {
+async function ensureLoggedIn(context, runtime) {
     renderRichText([ui.h1(`Checking if you are logged in...`), ui.blankLine()]);
     if (runtime) {
         let authInfo = null;
@@ -86,34 +63,17 @@ async function ensureLoggedIn(runtime, host) {
             // Do nothing, we don't mind if this fails
         }
         if (authInfo) {
-            renderAuthInfo(authInfo, runtime.token, runtime.baseUrl);
+            renderAuthInfo(authInfo, runtime.token, runtime.apiBaseUrl);
             return runtime;
         }
     }
     renderRichText([ui.p(`You are not logged in yet.`), ui.blankLine()]);
-    const parsed = host ? parseHostname(host) : { type: "cloud" };
-    if (parsed.type === "invalid") {
-        throw new CliError(`Could not recognize hostname "${host}". Expected app.getdx.com, <account>.getdx.io, or a custom domain.`);
-    }
-    switch (parsed.type) {
-        case "cloud":
-            return await attemptLogin("https://api.getdx.com", "https://app.getdx.com");
-        case "dedicated": {
-            const { accountName } = parsed;
-            return await attemptLogin(`https://api.${accountName}.getdx.io`, `https://${accountName}.getdx.io`);
-        }
-        case "managed": {
-            const apiBaseUrl = await input({
-                message: "What is your API base URL?",
-            });
-            if (!apiBaseUrl) {
-                throw new CliError("API base URL is required");
-            }
-            return await attemptLogin(apiBaseUrl, parsed.uiBaseUrl);
-        }
-    }
+    const { apiBaseUrl, webBaseUrl } = deriveBaseUrlsFromEnv();
+    return await attemptLogin(apiBaseUrl, webBaseUrl, context);
 }
-async function attemptLogin(apiBaseUrl, uiBaseUrl) {
+async function attemptLogin(apiBaseUrl, webBaseUrl, context) {
+    const logger = buildLogger(context);
+    logger.debug("Attempting login", { apiBaseUrl, webBaseUrl });
     const method = await select({
         message: "How would you like to log in?",
         choices: [
@@ -123,7 +83,7 @@ async function attemptLogin(apiBaseUrl, uiBaseUrl) {
     });
     let token;
     if (method === "browser") {
-        token = await loginViaBrowser(uiBaseUrl);
+        token = await loginViaBrowser(webBaseUrl);
     }
     else {
         token = await password({
@@ -134,17 +94,17 @@ async function attemptLogin(apiBaseUrl, uiBaseUrl) {
     if (!token) {
         throw new CliError("Account web API token is required");
     }
-    const context = createEmptyContext();
     const runtime = buildRuntime(context, {
-        baseUrl: apiBaseUrl,
+        apiBaseUrl,
         token,
+        webBaseUrl,
     });
     renderRichText([ui.blankLine(), ui.p(`Attempting login...`), ui.blankLine()]);
     const response = await getAuthInfo(runtime);
     if (!response.ok) {
         throw new CliError(`Login failed`);
     }
-    persistBaseUrl(apiBaseUrl);
+    persistBaseUrls(apiBaseUrl, webBaseUrl);
     setToken(apiBaseUrl, token);
     renderAuthInfo(response, token, apiBaseUrl);
     return runtime;
@@ -195,8 +155,3 @@ async function optionallySetupSkill(runtime) {
         throw new CliError(`Failed to setup the DX skill: ${result.stderr}`);
     }
 }
-function createEmptyContext() {
-    return {
-        json: false,
-    };
-}

package/dist/commands/scorecards.js

@@ -53,7 +53,7 @@ export function scorecardsCommand() {
             renderJson({ ok: true, scorecard: response.scorecard });
         }
         else {
-            renderScorecard(response.scorecard, null, `${ui.success(ui.GLYPHS.CHECK)} Scorecard created`);
+            renderScorecard(response.scorecard, null, runtime, `${ui.success(ui.GLYPHS.CHECK)} Scorecard created`);
         }
     }));
     scorecards
@@ -110,7 +110,7 @@ export function scorecardsCommand() {
             renderJson({ ok: true, scorecard: processedScorecard });
         }
         else {
-            renderScorecard(response.scorecard, includeSections);
+            renderScorecard(response.scorecard, includeSections, runtime);
         }
     }));
     scorecards
@@ -211,7 +211,7 @@ export function scorecardsCommand() {
             renderJson({ ...response, scorecards: processedScorecards });
         }
         else {
-            renderScorecardList(response.scorecards, response.response_metadata?.next_cursor ?? null, includeSections);
+            renderScorecardList(response.scorecards, response.response_metadata?.next_cursor ?? null, includeSections, runtime);
         }
     }));
     scorecards
@@ -256,7 +256,7 @@ export function scorecardsCommand() {
             renderJson({ ok: true, scorecard: response.scorecard });
         }
         else {
-            renderScorecard(response.scorecard, null, `${ui.success(ui.GLYPHS.CHECK)} Scorecard updated`);
+            renderScorecard(response.scorecard, null, runtime, `${ui.success(ui.GLYPHS.CHECK)} Scorecard updated`);
         }
     }));
     return scorecards;

package/dist/commands/scorecardsRendering.js

@@ -1,6 +1,6 @@
 import { renderRichText } from "../renderers.js";
 import * as ui from "../ui.js";
-export function renderScorecardList(scorecards, nextCursor, includeSections) {
+export function renderScorecardList(scorecards, nextCursor, includeSections, runtime) {
     const shouldIncludeAll = includeSections === null;
     const blocks = [ui.h1("Scorecards")];
     blocks.push(ui.p(`Displaying ${ui.bold(scorecards.length.toString())} scorecards.`));
@@ -11,7 +11,7 @@ export function renderScorecardList(scorecards, nextCursor, includeSections) {
         blocks.push(ui.h2(`${scorecard.name} (${ui.code(scorecard.id)})`));
         if (shouldIncludeAll || includeSections.includes("core")) {
             blocks.push(ui.h3("Basic details"));
-            blocks.push(...basicDetailsContent(scorecard));
+            blocks.push(...basicDetailsContent(scorecard, runtime));
             blocks.push(ui.h3("Entity filter"));
             blocks.push(...entityFilterContent(scorecard));
             if (scorecard.type === "LEVEL") {
@@ -34,12 +34,12 @@ export function renderScorecardList(scorecards, nextCursor, includeSections) {
     }
     renderRichText(blocks);
 }
-export function renderScorecard(scorecard, includeSections, title = "Scorecard Information") {
+export function renderScorecard(scorecard, includeSections, runtime, title = "Scorecard Information") {
     const shouldIncludeAll = includeSections === null;
     const blocks = [ui.h1(title)];
     if (shouldIncludeAll || includeSections.includes("core")) {
         blocks.push(ui.h2("Basic details"));
-        blocks.push(...basicDetailsContent(scorecard));
+        blocks.push(...basicDetailsContent(scorecard, runtime));
         blocks.push(ui.h2("Entity filter"));
         blocks.push(...entityFilterContent(scorecard));
         if (scorecard.type === "LEVEL") {
@@ -61,7 +61,7 @@ export function renderScorecard(scorecard, includeSections, title = "Scorecard I
     }
     renderRichText(blocks);
 }
-function basicDetailsContent(scorecard) {
+function basicDetailsContent(scorecard, runtime) {
     const items = [
         ui.dli("ID", [ui.p(ui.code(scorecard.id), false)]),
         ui.dli("Name", [ui.p(scorecard.name, false)]),
@@ -74,6 +74,9 @@ function basicDetailsContent(scorecard) {
         ui.dli("Published", [
             ui.p(scorecard.published ? ui.success("Yes") : ui.dim("No (draft)"), false),
         ]),
+        ui.dli("Web link", [
+            ui.p(ui.link(ui.webLink(`/scorecards/${scorecard.id}`, runtime)), false),
+        ]),
     ];
     if (scorecard.tags && scorecard.tags.length > 0) {
         items.push(ui.dli("Tags", [
@@ -97,7 +100,7 @@ function entityFilterContent(scorecard) {
     else if (scorecard.entity_filter_type === "sql") {
         blocks.push(ui.p(`Filter: ${ui.code("sql")}`));
         if (scorecard.entity_filter_sql) {
-            blocks.push(truncatedSqlBlock(scorecard.entity_filter_sql));
+            blocks.push(ui.truncatedSqlBlock(scorecard.entity_filter_sql));
         }
         else {
             blocks.push(ui.p(ui.dim("(No SQL provided)")));
@@ -190,7 +193,7 @@ function checkContent(check, scorecardType) {
     }
     // Query
     blocks.push(ui.p(ui.bold("Query:")));
-    blocks.push(truncatedSqlBlock(check.sql));
+    blocks.push(ui.truncatedSqlBlock(check.sql));
     // Output settings
     if (check.output_enabled) {
         const outputParts = [`Output: ${ui.code(check.output_type ?? "unknown")}`];
@@ -202,18 +205,10 @@ function checkContent(check, scorecardType) {
     // Entity filter
     if (check.filter_sql) {
         blocks.push(ui.p(ui.bold("Entity filter:")));
-        blocks.push(truncatedSqlBlock(check.filter_sql));
+        blocks.push(ui.truncatedSqlBlock(check.filter_sql));
         if (check.filter_message) {
             blocks.push(ui.p(`Excluded message: ${ui.dim(check.filter_message)}`, false));
         }
     }
     return blocks;
 }
-function truncatedSqlBlock(sql) {
-    const lines = sql.split("\n");
-    const firstLine = lines[0];
-    const isLong = firstLine.length > 80 || lines.length > 1;
-    const truncated = firstLine.length > 80 ? firstLine.slice(0, 80) : firstLine;
-    const display = isLong ? truncated + ui.dim(" …") : truncated;
-    return ui.p(ui.code(display));
-}

package/dist/commands/studio/query.js

@@ -144,13 +144,13 @@ async function getStudioQueryResults(runtime, id) {
     return response.body;
 }
 async function downloadStudioQueryResultsCsv(runtime, id, filename) {
-    const response = await fetchWithApiHeaders(runtime, `${runtime.baseUrl}/studio.queryRuns.results?id=${encodeURIComponent(id)}&format=csv`, { redirect: "manual" });
+    const response = await fetchWithApiHeaders(runtime, `${runtime.apiBaseUrl}/studio.queryRuns.results?id=${encodeURIComponent(id)}&format=csv`, { redirect: "manual" });
     if (response.status >= 300 && response.status < 400) {
         const location = response.headers.get("location");
         if (!location) {
             throw new HttpError("CSV download redirect did not include a Location header.", response.status);
         }
-        const downloadResponse = await fetchResponse(new URL(location, runtime.baseUrl).toString(), {
+        const downloadResponse = await fetchResponse(new URL(location, runtime.apiBaseUrl).toString(), {
             method: "GET",
             headers: buildDownloadHeaders(runtime, "text/csv"),
         });

package/dist/commands/workflows.js

@@ -0,0 +1,82 @@
+import { Command } from "commander";
+import { createExampleText, getContext, wrapAction, } from "../commandHelpers.js";
+import { CliError, EXIT_CODES } from "../errors.js";
+import { request } from "../http.js";
+import { renderJson } from "../renderers.js";
+import { buildRuntime } from "../runtime.js";
+import { renderWorkflowList } from "./workflowsRendering.js";
+const WORKFLOW_SCOPES = ["GLOBAL", "ENTITY"];
+export function workflowsCommand() {
+    const workflows = new Command()
+        .name("workflows")
+        .description("Manage Self-service workflow definitions");
+    workflows
+        .command("list")
+        .description("List Self-service workflows for the account")
+        .option("--scope <scope>", "Filter by workflow scope: GLOBAL or ENTITY (omit for both)")
+        .option("--entity-identifier <id>", "Catalog entity identifier; must be used with --scope ENTITY")
+        .addHelpText("afterAll", createExampleText([
+        {
+            label: "List workflows the token can trigger",
+            command: "dx workflows list",
+        },
+        {
+            label: "Entity-scoped workflows for a catalog entity",
+            command: "dx workflows list --scope ENTITY --entity-identifier acme-app",
+        },
+        {
+            label: "Same request as JSON",
+            command: "dx --json workflows list --scope ENTITY --entity-identifier acme-app",
+        },
+    ]))
+        .action(wrapAction(async (options, command) => {
+        const scope = parseOptionalScope(options.scope);
+        const entityIdentifier = parseOptionalTrimmed(options.entityIdentifier);
+        if (entityIdentifier && scope !== "ENTITY") {
+            throw new CliError("--entity-identifier requires --scope ENTITY", EXIT_CODES.ARGUMENT_ERROR);
+        }
+        const runtime = buildRuntime(getContext(command));
+        const response = await listWorkflows(runtime, {
+            scope,
+            entity_identifier: entityIdentifier,
+        });
+        if (runtime.context.json) {
+            renderJson(response);
+        }
+        else {
+            renderWorkflowList(response.workflows);
+        }
+    }));
+    return workflows;
+}
+function parseOptionalTrimmed(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const t = value.trim();
+    return t.length > 0 ? t : undefined;
+}
+function parseOptionalScope(value) {
+    const raw = parseOptionalTrimmed(value);
+    if (raw === undefined) {
+        return undefined;
+    }
+    if (!WORKFLOW_SCOPES.includes(raw)) {
+        throw new CliError(`--scope must be one of: ${WORKFLOW_SCOPES.join(", ")}`, EXIT_CODES.ARGUMENT_ERROR);
+    }
+    return raw;
+}
+// --- API ---
+async function listWorkflows(runtime, params) {
+    const query = {};
+    if (params.scope !== undefined)
+        query.scope = params.scope;
+    if (params.entity_identifier !== undefined) {
+        query.entity_identifier = params.entity_identifier;
+    }
+    const response = await request(runtime, "/workflows.list", {
+        method: "GET",
+        query,
+    });
+    return response.body;
+}

package/dist/commands/workflowsRendering.js

@@ -0,0 +1,136 @@
+import { renderRichText } from "../renderers.js";
+import * as ui from "../ui.js";
+const WORKFLOW_SCOPE_LABELS = {
+    GLOBAL: "Global",
+    ENTITY: "Catalog entity",
+};
+const WORKFLOW_EXECUTION_TYPE_LABELS = {
+    SIMPLE: "Simple",
+    EVENT_DRIVEN: "Event-driven",
+};
+const WORKFLOW_TRIGGER_TYPE_LABELS = {
+    ANY: "All users",
+    APPROVAL: "All users with approval",
+    RUNNERS: "Selected teams and users",
+    ENTITY: "Entity owners only",
+};
+const WORKFLOW_TRIGGER_TYPE_DESCRIPTIONS = {
+    ANY: "All users can trigger this workflow run without approval.",
+    APPROVAL: "All users can request a workflow run, but a designated approver must accept before it runs.",
+    RUNNERS: "Only selected teams or users can trigger a workflow run.",
+    ENTITY: "Only users who directly own the entity, or belong to an owning team, can trigger a run.",
+};
+function workflowScopeLabel(scope) {
+    return WORKFLOW_SCOPE_LABELS[scope] ?? scope;
+}
+function workflowExecutionTypeLabel(executionType) {
+    return WORKFLOW_EXECUTION_TYPE_LABELS[executionType] ?? executionType;
+}
+function workflowTriggerTypeLabel(triggerType) {
+    return WORKFLOW_TRIGGER_TYPE_LABELS[triggerType] ?? triggerType;
+}
+function workflowTriggerTypeDescription(triggerType) {
+    return WORKFLOW_TRIGGER_TYPE_DESCRIPTIONS[triggerType] ?? "";
+}
+export function renderWorkflowList(workflows) {
+    const blocks = [
+        ui.h1("Workflows"),
+        ui.p(`Displaying ${ui.bold(workflows.length.toString())} workflows.`),
+    ];
+    for (const workflow of workflows) {
+        blocks.push(ui.h2(`${workflow.name} (${ui.code(workflow.identifier)})`));
+        blocks.push(ui.h3("Core attributes"));
+        blocks.push(...coreContent(workflow));
+        if (workflow.scope === "ENTITY") {
+            blocks.push(ui.h3("Entity filter"));
+            blocks.push(...entityFilterContent(workflow));
+        }
+        blocks.push(ui.h3("Parameters"));
+        blocks.push(...parametersContent(workflow));
+    }
+    renderRichText(blocks);
+}
+function coreContent(workflow) {
+    const blocks = [];
+    const description = workflow.description?.trim()
+        ? workflow.description
+        : ui.dim("(None)");
+    blocks.push(ui.dl([
+        ui.dli("Description", description),
+        ui.dli("Scope", workflowScopeLabel(workflow.scope)),
+        ui.dli("Execution type", workflowExecutionTypeLabel(workflow.execution_type)),
+        ui.dli("Who can run", `${workflowTriggerTypeLabel(workflow.trigger_type)}  ${ui.dim(workflowTriggerTypeDescription(workflow.trigger_type))}`),
+    ], { termWidth: 16 }));
+    return blocks;
+}
+function entityFilterContent(workflow) {
+    const blocks = [];
+    if (workflow.entity_filter_type === "ENTITY_TYPES") {
+        blocks.push(ui.p(`Filter type: ${ui.code("Entity types")}`));
+        if (workflow.entity_filter_type_identifiers &&
+            workflow.entity_filter_type_identifiers.length > 0) {
+            blocks.push(ui.ul(workflow.entity_filter_type_identifiers.map((identifier) => ui.li([ui.p(ui.code(identifier), false)]))));
+        }
+    }
+    else if (workflow.entity_filter_type === "SQL") {
+        blocks.push(ui.p(`Filter type: ${ui.code("SQL")}`));
+        if (workflow.entity_filter_sql) {
+            blocks.push(ui.truncatedSqlBlock(workflow.entity_filter_sql));
+        }
+    }
+    return blocks;
+}
+function parametersContent(workflow) {
+    if (workflow.parameters.length === 0) {
+        return [ui.p(ui.dim("(No parameters)"))];
+    }
+    return [
+        ui.ul(workflow.parameters.map((parameter) => ui.li(singleParameterContent(parameter)))),
+    ];
+}
+function singleParameterContent(parameter) {
+    const requiredPart = parameter.is_required ? `  ${ui.dim("required")}` : "";
+    const headline = `${ui.bold(parameter.name)} (${ui.code(parameter.identifier)})  ${ui.code(parameter.type)}${requiredPart}`;
+    const blocks = [ui.p(headline, false)];
+    const desc = parameter.description?.trim();
+    if (desc) {
+        blocks.push(ui.p(desc, false));
+    }
+    if (parameter.default_value !== null &&
+        parameter.default_value !== undefined &&
+        parameter.default_value !== "") {
+        blocks.push(ui.p(`Default: ${ui.code(formatParameterDefault(parameter.default_value))}`, false));
+    }
+    if (parameter.type === "SELECT") {
+        const options = selectParameterOptions(parameter.definition);
+        if (options.length > 0) {
+            blocks.push(ui.p("Options:", false));
+            blocks.push(ui.ul(options.map((value) => ui.li([ui.p(ui.code(value), false)]))));
+        }
+    }
+    return blocks;
+}
+function selectParameterOptions(definition) {
+    if (!definition || typeof definition !== "object") {
+        return [];
+    }
+    const raw = definition.options;
+    if (!Array.isArray(raw)) {
+        return [];
+    }
+    return raw.filter((item) => typeof item === "string");
+}
+function formatParameterDefault(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+    }
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}