@get-dx/cli 0.2.1 → 0.3.1

package/dist/commands/snapshots.js

@@ -0,0 +1,379 @@
+import { Command } from "commander";
+import { createExampleText, getContext, parsePositiveIntOption, wrapAction, } from "../commandHelpers.js";
+import { CliError, EXIT_CODES } from "../errors.js";
+import { request } from "../http.js";
+import { renderJson, renderRichText } from "../renderers.js";
+import { buildRuntime } from "../runtime.js";
+import * as ui from "../ui.js";
+export function snapshotsCommand() {
+    const snapshots = new Command()
+        .name("snapshots")
+        .description("Work with DX snapshots");
+    const csatComments = new Command()
+        .name("csatComments")
+        .description("Work with snapshot CSAT comments");
+    csatComments
+        .command("list")
+        .description("List CSAT comments for a snapshot")
+        .option("--id <id>", "The unique ID of the snapshot")
+        .option("--cursor <cursor>", "Cursor for the next page of results")
+        .option("--limit <n>", "Max comments per page (default is 50, max is 100)", (value) => parseLimitOption(value, "--limit"))
+        .addHelpText("afterAll", createExampleText([
+        {
+            label: "List CSAT comments for a snapshot",
+            command: "dx snapshots csatComments list --id MjUyNbaY",
+        },
+        {
+            label: "List CSAT comments as JSON",
+            command: "dx --json snapshots csatComments list --id MjUyNbaY",
+        },
+        {
+            label: "Fetch the next page using a cursor from the prior response",
+            command: "dx snapshots csatComments list --id MjUyNbaY --cursor xuvkgfq9t0ty --limit 100",
+        },
+    ]))
+        .action(wrapAction(async (options, command) => {
+        const id = parseRequiredTextOption(options.id, "--id");
+        const runtime = buildRuntime(getContext(command));
+        const response = await listSnapshotCsatComments(runtime, {
+            id,
+            cursor: options.cursor,
+            limit: options.limit,
+        });
+        if (runtime.context.json) {
+            renderJson(response);
+        }
+        else {
+            renderSnapshotCsatComments(extractCsatComments(response), response.response_metadata?.next_cursor ?? null, id, runtime);
+        }
+    }));
+    snapshots.addCommand(csatComments);
+    const driverComments = new Command()
+        .name("driverComments")
+        .description("Work with snapshot driver comments");
+    driverComments
+        .command("list")
+        .description("List driver comments for a snapshot")
+        .option("--id <id>", "The unique ID of the snapshot")
+        .option("--cursor <cursor>", "Cursor for the next page of results")
+        .option("--limit <n>", "Max comments per page (default is 50, max is 100)", (value) => parseLimitOption(value, "--limit"))
+        .addHelpText("afterAll", createExampleText([
+        {
+            label: "List driver comments for a snapshot",
+            command: "dx snapshots driverComments list --id MjUyNbaY",
+        },
+        {
+            label: "List driver comments as JSON",
+            command: "dx --json snapshots driverComments list --id MjUyNbaY",
+        },
+        {
+            label: "Fetch the next page using a cursor from the prior response",
+            command: "dx snapshots driverComments list --id MjUyNbaY --cursor xuvkgfq9t0ty --limit 100",
+        },
+    ]))
+        .action(wrapAction(async (options, command) => {
+        const id = parseRequiredTextOption(options.id, "--id");
+        const runtime = buildRuntime(getContext(command));
+        const response = await listSnapshotDriverComments(runtime, {
+            id,
+            cursor: options.cursor,
+            limit: options.limit,
+        });
+        if (runtime.context.json) {
+            renderJson(response);
+        }
+        else {
+            renderSnapshotDriverComments(extractDriverComments(response), response.response_metadata?.next_cursor ?? null, id, runtime);
+        }
+    }));
+    snapshots.addCommand(driverComments);
+    snapshots
+        .command("info")
+        .description("Retrieve results for a single snapshot")
+        .option("--id <snapshot_id>", "The unique ID of the snapshot")
+        .addHelpText("afterAll", createExampleText([
+        {
+            label: "Fetch info for a snapshot",
+            command: "dx snapshots info --id MjUyNbaY",
+        },
+        {
+            label: "Fetch snapshot info as JSON",
+            command: "dx --json snapshots info --id MjUyNbaY",
+        },
+    ]))
+        .action(wrapAction(async (options, command) => {
+        const snapshotId = parseRequiredTextOption(options.id, "--id");
+        const runtime = buildRuntime(getContext(command));
+        const response = await getSnapshotInfo(runtime, snapshotId);
+        if (runtime.context.json) {
+            renderJson(response);
+        }
+        else {
+            renderSnapshotInfo(response.snapshot, snapshotId, runtime);
+        }
+    }));
+    snapshots
+        .command("list")
+        .description("List DX snapshots")
+        .addHelpText("afterAll", createExampleText([
+        {
+            label: "List snapshots",
+            command: "dx snapshots list",
+        },
+        {
+            label: "List snapshots as JSON",
+            command: "dx --json snapshots list",
+        },
+    ]))
+        .action(wrapAction(async (_options, command) => {
+        const runtime = buildRuntime(getContext(command));
+        const response = await listSnapshots(runtime);
+        if (runtime.context.json) {
+            renderJson(response);
+        }
+        else {
+            renderSnapshots(response.snapshots, runtime);
+        }
+    }));
+    return snapshots;
+}
+async function listSnapshotDriverComments(runtime, options) {
+    const response = await request(runtime, "/snapshots.driverComments.list", {
+        method: "GET",
+        query: {
+            id: options.id,
+            cursor: options.cursor,
+            limit: options.limit,
+        },
+    });
+    return response.body;
+}
+async function listSnapshotCsatComments(runtime, options) {
+    const response = await request(runtime, "/snapshots.csatComments.list", {
+        method: "GET",
+        query: {
+            id: options.id,
+            cursor: options.cursor,
+            limit: options.limit,
+        },
+    });
+    return response.body;
+}
+async function getSnapshotInfo(runtime, snapshotId) {
+    const response = await request(runtime, "/snapshots.info", {
+        method: "GET",
+        query: { snapshot_id: snapshotId },
+    });
+    return response.body;
+}
+async function listSnapshots(runtime) {
+    const response = await request(runtime, "/snapshots.list", {
+        method: "GET",
+        query: {
+            ordering: "completed_at",
+        },
+    });
+    return response.body;
+}
+function renderSnapshotDriverComments(comments, nextCursor, snapshotId, runtime) {
+    const blocks = [ui.h1("Snapshot Driver Comments")];
+    blocks.push(ui.p(`Displaying ${ui.bold(comments.length.toString())} comments.`));
+    blocks.push(ui.p(ui.link(snapshotWebLink(snapshotId, "drivers/comments", runtime))));
+    if (nextCursor) {
+        blocks.push(ui.p(`Next cursor: ${ui.code(nextCursor)}`));
+    }
+    if (comments.length === 0) {
+        blocks.push(ui.p(ui.dim("(None)")));
+        renderRichText(blocks);
+        return;
+    }
+    for (const comment of comments) {
+        blocks.push(ui.h2(formatCommentHeading(comment)));
+        const details = [
+            optionalDetail("Email", formatText(comment.email), comment.email),
+            optionalDetail("Driver", formatText(comment.driver_name ?? comment.driver), comment.driver_name ?? comment.driver),
+            optionalDetail("Driver ID", formatText(comment.driver_id), comment.driver_id),
+            optionalDetail("Team", formatText(comment.team_name), comment.team_name),
+            optionalDetail("Team ID", formatText(comment.team_id), comment.team_id),
+            optionalDetail("Item", formatText(comment.item_name), comment.item_name),
+            optionalDetail("Item ID", formatText(comment.item_id), comment.item_id),
+            optionalDetail("Snapshot ID", formatText(comment.snapshot_id), comment.snapshot_id),
+            optionalDetail("Timestamp", formatTimestamp(comment.timestamp), comment.timestamp),
+        ].filter((detail) => detail !== null);
+        if (details.length > 0) {
+            blocks.push(ui.dl(details, { termWidth: 11 }));
+        }
+        blocks.push(ui.p(formatText(comment.text ?? comment.comment)));
+    }
+    renderRichText(blocks);
+}
+function renderSnapshotCsatComments(comments, nextCursor, snapshotId, runtime) {
+    const blocks = [ui.h1("Snapshot CSAT Comments")];
+    blocks.push(ui.p(`Displaying ${ui.bold(comments.length.toString())} comments.`));
+    blocks.push(ui.p(ui.link(snapshotWebLink(snapshotId, "csat/comments", runtime))));
+    if (nextCursor) {
+        blocks.push(ui.p(`Next cursor: ${ui.code(nextCursor)}`));
+    }
+    if (comments.length === 0) {
+        blocks.push(ui.p(ui.dim("(None)")));
+        renderRichText(blocks);
+        return;
+    }
+    for (const comment of comments) {
+        blocks.push(ui.h2(formatCommentHeading(comment)));
+        const details = [
+            optionalDetail("Email", formatText(comment.email), comment.email),
+            optionalDetail("Team", formatText(comment.team_name), comment.team_name),
+            optionalDetail("Team ID", formatText(comment.team_id), comment.team_id),
+            optionalDetail("Item", formatText(comment.item_name), comment.item_name),
+            optionalDetail("Item ID", formatText(comment.item_id), comment.item_id),
+            optionalDetail("Snapshot ID", formatText(comment.snapshot_id), comment.snapshot_id),
+            optionalDetail("Timestamp", formatTimestamp(comment.timestamp), comment.timestamp),
+        ].filter((detail) => detail !== null);
+        if (details.length > 0) {
+            blocks.push(ui.dl(details, { termWidth: 11 }));
+        }
+        blocks.push(ui.p(formatText(comment.text ?? comment.comment)));
+    }
+    renderRichText(blocks);
+}
+function renderSnapshotInfo(snapshot, snapshotId, runtime) {
+    const teamScores = snapshot.team_scores ?? [];
+    const blocks = [ui.h1("Snapshot Information")];
+    blocks.push(ui.p(`Displaying ${ui.bold(teamScores.length.toString())} team scores.`));
+    blocks.push(ui.p(ui.link(snapshotWebLink(snapshotId, "drivers", runtime))));
+    if (teamScores.length === 0) {
+        blocks.push(ui.p(ui.dim("(None)")));
+        renderRichText(blocks);
+        return;
+    }
+    for (const teamScore of teamScores) {
+        blocks.push(ui.h2("Team Score"));
+        blocks.push(ui.dl([
+            optionalDetail("Team name", formatText(teamScore.snapshot_team?.name), teamScore.snapshot_team?.name),
+            optionalDetail("Team ID", formatText(teamScore.snapshot_team?.team_id), teamScore.snapshot_team?.team_id),
+            optionalDetail("item_name", formatText(teamScore.item_name), teamScore.item_name),
+            optionalDetail("Response count", formatNumber(teamScore.response_count), teamScore.response_count),
+            optionalDetail("Score", formatNumber(teamScore.score), teamScore.score),
+        ].filter((detail) => detail !== null), { termWidth: 16 }));
+        blocks.push(ui.h3("Benchmarks"));
+        blocks.push(ui.p(formatBenchmarkTable(teamScore)));
+    }
+    renderRichText(blocks);
+}
+function renderSnapshots(snapshots, runtime) {
+    const blocks = [ui.h1("Snapshots")];
+    blocks.push(ui.p(`Displaying ${ui.bold(snapshots.length.toString())} snapshots.`));
+    if (snapshots.length === 0) {
+        blocks.push(ui.p(ui.dim("(None)")));
+        renderRichText(blocks);
+        return;
+    }
+    for (const snapshot of snapshots) {
+        blocks.push(ui.h2(ui.code(snapshot.id)));
+        blocks.push(ui.dl([
+            optionalDetail("Account ID", formatText(snapshot.account_id), snapshot.account_id),
+            optionalDetail("Scheduled for", formatText(snapshot.scheduled_for), snapshot.scheduled_for),
+            optionalDetail("Completed", formatTimestamp(snapshot.completed_at), snapshot.completed_at),
+            optionalDetail("Completed count", formatNumber(snapshot.completed_count), snapshot.completed_count),
+            optionalDetail("Total count", formatNumber(snapshot.total_count), snapshot.total_count),
+            optionalDetail("Last result change", formatTimestamp(snapshot.last_result_change_at), snapshot.last_result_change_at),
+            optionalDetail("Deleted", formatTimestamp(snapshot.deleted_at), snapshot.deleted_at),
+            ui.dli("Web link", ui.link(snapshotWebLink(snapshot.id, "drivers", runtime))),
+        ].filter((detail) => detail !== null), { termWidth: 18 }));
+    }
+    renderRichText(blocks);
+}
+function extractDriverComments(response) {
+    return (response.driver_comments ??
+        response.driverComments ??
+        response.drivercomments ??
+        response.comments ??
+        []);
+}
+function extractCsatComments(response) {
+    return (response.csat_comments ??
+        response.csatComments ??
+        response.csatcomments ??
+        response.comments ??
+        []);
+}
+function formatCommentHeading(comment) {
+    const heading = comment.item_name ??
+        comment.driver_name ??
+        comment.driver ??
+        comment.email ??
+        comment.item_id ??
+        comment.driver_id;
+    return typeof heading === "string" && heading.trim().length > 0
+        ? heading
+        : "Comment";
+}
+function formatText(value) {
+    return typeof value === "string" && value.trim().length > 0
+        ? value
+        : ui.dim("(None)");
+}
+function formatNumber(value) {
+    return typeof value === "number" && Number.isFinite(value)
+        ? value.toString()
+        : ui.dim("(None)");
+}
+function formatTimestamp(value) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        return "";
+    }
+    const trimmed = value.trim();
+    const seconds = Number(trimmed);
+    if (Number.isFinite(seconds) && seconds > 0) {
+        return ui.timestampSummary(new Date(seconds * 1000).toISOString());
+    }
+    return Number.isNaN(Date.parse(trimmed))
+        ? trimmed
+        : ui.timestampSummary(trimmed);
+}
+function optionalDetail(term, value, rawValue) {
+    if (rawValue === undefined || rawValue === null) {
+        return null;
+    }
+    if (typeof rawValue === "string" && rawValue.trim().length === 0) {
+        return null;
+    }
+    return ui.dli(term, value);
+}
+function formatBenchmarkTable(teamScore) {
+    const rows = [
+        ["vs_prev", formatBenchmarkNumber(teamScore.vs_prev)],
+        ["vs_org", formatBenchmarkNumber(teamScore.vs_org)],
+        ["vs_50th", formatBenchmarkNumber(teamScore.vs_50th)],
+        ["vs_75th", formatBenchmarkNumber(teamScore.vs_75th)],
+        ["vs_90th", formatBenchmarkNumber(teamScore.vs_90th)],
+    ];
+    const columns = ["Benchmark", "Value"];
+    const widths = columns.map((column, index) => Math.max(column.length, ...rows.map((row) => row[index].length)));
+    const border = `+${widths.map((width) => "-".repeat(width + 2)).join("+")}+`;
+    const header = `| ${columns.map((column, index) => column.padEnd(widths[index])).join(" | ")} |`;
+    const body = rows.map((row) => `| ${row.map((cell, index) => cell.padEnd(widths[index])).join(" | ")} |`);
+    return [border, header, border, ...body, border].join("\n");
+}
+function formatBenchmarkNumber(value) {
+    return typeof value === "number" && Number.isFinite(value)
+        ? value.toString()
+        : "(None)";
+}
+function snapshotWebLink(snapshotId, section, runtime) {
+    return ui.webLink(`/snapshots/${snapshotId}/${section}`, runtime);
+}
+function parseRequiredTextOption(value, flag) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new CliError(`${flag} is required`, EXIT_CODES.ARGUMENT_ERROR);
+    }
+    return value.trim();
+}
+function parseLimitOption(value, flag) {
+    const limit = parsePositiveIntOption(value, flag);
+    if (limit > 100) {
+        throw new CliError(`${flag} must be at most 100`, EXIT_CODES.ARGUMENT_ERROR);
+    }
+    return limit;
+}

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

@@ -1,14 +1,10 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-const DEFAULT_BASE_URL = "https://api.getdx.com";
-export function getConfigDir() {
-    const xdg = process.env.XDG_CONFIG_HOME;
-    if (xdg) {
-        return path.join(xdg, "dx");
-    }
-    return path.join(os.homedir(), ".config", "dx");
-}
+import { CliError, EXIT_CODES } from "./errors.js";
+const DEFAULT_API_BASE_URL = "https://api.getdx.com";
+const DEFAULT_WEB_BASE_URL = "https://app.getdx.com";
+// --- Config file I/O ---------------------------------------------------------
 export function getConfigPath() {
     return path.join(getConfigDir(), "config.json");
 }
@@ -18,38 +14,184 @@ export function readConfig() {
         return {};
     }
     const content = fs.readFileSync(configPath, "utf8");
-    return JSON.parse(content);
+    const raw = JSON.parse(content);
+    const api = raw.apiBaseUrl;
+    const web = raw.webBaseUrl;
+    const stored = {};
+    if (web) {
+        stored.webBaseUrl = web;
+    }
+    if (api) {
+        stored.apiBaseUrl = api;
+    }
+    return stored;
+}
+/**
+ * Responsible for handling the migration from `baseUrl` to `apiBaseUrl` and `webBaseUrl`,
+ * so the upgrade to 0.3.x will be non-breaking for `cloud` and `dedicated` deployments.
+ *
+ * `managed` deployments will encounter an error and will have to reauthenticate.
+ *
+ * TODO: delete after 2026-07-01.
+ */
+export function handleTemporaryBaseUrlMigration(argv) {
+    if (!process.env.VITEST) {
+        // Running tests - we don't want our permanent tests to exercise this logic
+        return;
+    }
+    const COMMANDS_TO_SKIP_MIGRATION = ["login", "logout", "init"];
+    if (COMMANDS_TO_SKIP_MIGRATION.some((command) => argv.includes(command))) {
+        // Logging in or logging out: we need to ignore the current config file's contents
+        return;
+    }
+    const configPath = getConfigPath();
+    if (!fs.existsSync(configPath)) {
+        // No config file, no need to migrate
+        return;
+    }
+    const content = fs.readFileSync(configPath, "utf8");
+    const raw = JSON.parse(content);
+    const api = raw.apiBaseUrl;
+    const web = raw.webBaseUrl;
+    if (api !== undefined && web !== undefined) {
+        // Already migrated, no need to do anything
+        return;
+    }
+    if (raw.baseUrl) {
+        // Legacy baseUrl is present, migrate to apiBaseUrl and webBaseUrl
+        const apiBaseUrl = raw.baseUrl;
+        let webBaseUrl;
+        if (apiBaseUrl.endsWith(".getdx.com")) {
+            // Migrate `cloud`
+            webBaseUrl = "https://app.getdx.com";
+            writeConfig({
+                apiBaseUrl: normalizeUrl(apiBaseUrl),
+                webBaseUrl: normalizeUrl(webBaseUrl),
+            });
+            return;
+        }
+        const dedicatedMatch = apiBaseUrl.match(/^api\.(.+)\.getdx\.io$/);
+        if (dedicatedMatch) {
+            // Migrate `dedicated`
+            webBaseUrl = `https://${dedicatedMatch[1]}.getdx.io`;
+            writeConfig({
+                apiBaseUrl: normalizeUrl(apiBaseUrl),
+                webBaseUrl: normalizeUrl(webBaseUrl),
+            });
+            return;
+        }
+        // Unable to automatically migrate `managed`
+        throw new CliError("Your on-disk DX CLI config is missing apiBaseUrl and webBaseUrl. Run `dx auth logout`, then login again via `dx init` or `dx auth login`.");
+    }
 }
 export function writeConfig(config) {
     fs.mkdirSync(getConfigDir(), { recursive: true });
     fs.writeFileSync(getConfigPath(), JSON.stringify(config, null, 2) + "\n", "utf8");
 }
-export function resolveBaseUrl() {
-    if (process.env.DX_BASE_URL) {
-        return normalizeBaseUrl(process.env.DX_BASE_URL);
+export function persistBaseUrls(apiBaseUrl, webBaseUrl) {
+    writeConfig({
+        ...readConfig(),
+        apiBaseUrl: normalizeUrl(apiBaseUrl),
+        webBaseUrl: normalizeUrl(webBaseUrl),
+    });
+}
+/** Strips trailing slashes from an HTTP(S) base URL string. */
+export function normalizeUrl(url) {
+    return url.replace(/\/+$/, "");
+}
+function getConfigDir() {
+    const xdg = process.env.XDG_CONFIG_HOME;
+    if (xdg) {
+        return path.join(xdg, "dx");
     }
-    return normalizeBaseUrl(readConfig().baseUrl || DEFAULT_BASE_URL);
+    return path.join(os.homedir(), ".config", "dx");
 }
+// --- Resolving URLs at command runtime ------------------------------------------------------
 /**
- * Web UI origin for browser OAuth (`/cli/auth`), inferred from the API base URL.
- * Dedicated and cloud hostnames map to their app origins; otherwise the API URL origin is used.
+ * Resolved API base URL for HTTP requests.
+ * Precedence: `DX_API_BASE_URL`, then persisted `apiBaseUrl`, then DX Cloud default.
  */
-export function resolveUiUrl(apiBaseUrl) {
-    const normalized = normalizeBaseUrl(apiBaseUrl);
-    const url = new URL(normalized);
-    const host = url.hostname;
-    if (host === "api.getdx.com") {
-        return "https://app.getdx.com";
+export function resolveApiBaseUrl() {
+    if (process.env.DX_API_BASE_URL) {
+        return normalizeUrl(process.env.DX_API_BASE_URL);
     }
-    const dedicated = host.match(/^api\.(.+)\.getdx\.io$/);
-    if (dedicated) {
-        return `https://${dedicated[1]}.getdx.io`;
+    return normalizeUrl(readConfig().apiBaseUrl || DEFAULT_API_BASE_URL);
+}
+/**
+ * Resolved web-app base URL for CLI deep links and browser OAuth.
+ * Precedence: `DX_WEB_BASE_URL`, persisted `webBaseUrl`, then DX Cloud default.
+ */
+export function resolveWebBaseUrl() {
+    if (process.env.DX_WEB_BASE_URL) {
+        return normalizeUrl(process.env.DX_WEB_BASE_URL);
     }
-    return url.origin;
+    return normalizeUrl(readConfig().webBaseUrl || DEFAULT_WEB_BASE_URL);
 }
-export function persistBaseUrl(baseUrl) {
-    writeConfig({ ...readConfig(), baseUrl: normalizeBaseUrl(baseUrl) });
+// --- Deriving base URLs at login time -------------------------------------
+/**
+ * Derive the appropriate `apiBaseUrl` and `webBaseUrl` to persist into config,
+ * considering the `DX_API_BASE_URL` and `DX_WEB_BASE_URL` env vars if they are present.
+ *
+ * If the env vars are not set, we assume the user is configuring for a `cloud` deployment.
+ *
+ * If they are set, we parse them to determine whether the deployment is `cloud`, `dedicated`, or `managed`.
+ *
+ * If we fail to derive the base URLs, a `CliError` is thrown.
+ */
+export function deriveBaseUrlsFromEnv() {
+    const apiBaseUrlFromEnv = process.env.DX_API_BASE_URL;
+    const webBaseUrlFromEnv = process.env.DX_WEB_BASE_URL;
+    if (apiBaseUrlFromEnv && !webBaseUrlFromEnv) {
+        throw new CliError("DX_WEB_BASE_URL must be set when DX_API_BASE_URL is set", EXIT_CODES.ARGUMENT_ERROR);
+    }
+    const parsed = webBaseUrlFromEnv
+        ? parseWebBaseUrl(webBaseUrlFromEnv)
+        : { type: "cloud" };
+    switch (parsed.type) {
+        case "cloud":
+            return {
+                apiBaseUrl: "https://api.getdx.com",
+                webBaseUrl: "https://app.getdx.com",
+            };
+        case "dedicated": {
+            const { accountName } = parsed;
+            return {
+                apiBaseUrl: `https://api.${accountName}.getdx.io`,
+                webBaseUrl: `https://${accountName}.getdx.io`,
+            };
+        }
+        case "managed": {
+            const apiBaseUrl = process.env.DX_API_BASE_URL;
+            if (!apiBaseUrl) {
+                throw new CliError("DX_API_BASE_URL must be specified when authenticating with a managed deployment");
+            }
+            return {
+                apiBaseUrl,
+                webBaseUrl: parsed.webAppUrl,
+            };
+        }
+        case "invalid":
+            throw new CliError(`Could not recognize web base URL "${parsed.input}". Expected https://app.getdx.com, https://<account>.getdx.io, or a custom domain.`);
+    }
 }
-function normalizeBaseUrl(baseUrl) {
-    return baseUrl.replace(/\/+$/, "");
+function parseWebBaseUrl(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", webAppUrl: url.origin };
+        }
+    }
+    catch {
+        // fall through to invalid
+    }
+    return { type: "invalid", input: raw };
 }

package/dist/http.js

@@ -23,7 +23,7 @@ export async function request(runtime, route, options = {}) {
             query.set(key, String(value));
         }
     });
-    const url = `${runtime.baseUrl}${route}${query.size > 0 ? `?${query.toString()}` : ""}`;
+    const url = `${runtime.apiBaseUrl}${route}${query.size > 0 ? `?${query.toString()}` : ""}`;
     const requestBody = options.body !== undefined ? JSON.stringify(options.body) : undefined;
     runtime.logger.debug("Sending HTTP request", {
         body: options.body ?? null,

package/dist/loginViaBrowser.js

@@ -4,7 +4,7 @@ import { AuthCodeCallbackServer, } from "./authCodeCallbackServer.js";
 import { CliError } from "./errors.js";
 import { renderRichText } from "./renderers.js";
 import * as ui from "./ui.js";
-export async function loginViaBrowser(uiBaseUrl) {
+export async function loginViaBrowser(webBaseUrl) {
     const server = new AuthCodeCallbackServer();
     await server.start();
     const callbackUri = server.getAddress();
@@ -17,7 +17,7 @@ export async function loginViaBrowser(uiBaseUrl) {
         code_challenge: codeChallenge,
         code_challenge_method: "S256",
     });
-    const authUrl = `${uiBaseUrl}/cli/auth?${params.toString()}`;
+    const authUrl = `${webBaseUrl}/cli/auth?${params.toString()}`;
     renderRichText([
         ui.p(`Opening your browser to complete authentication...`),
         ui.blankLine(),
@@ -42,7 +42,7 @@ export async function loginViaBrowser(uiBaseUrl) {
                 error: new CliError("Authentication failed: state mismatch"),
             };
         }
-        const tokenExchangeResponse = await exchangeCodeForToken(uiBaseUrl, code, codeVerifier);
+        const tokenExchangeResponse = await exchangeCodeForToken(webBaseUrl, code, codeVerifier);
         if (!tokenExchangeResponse.ok) {
             return {
                 type: "ERROR",
@@ -64,8 +64,8 @@ export async function loginViaBrowser(uiBaseUrl) {
 function validateState(stateFromResponse, originalState) {
     return stateFromResponse === originalState;
 }
-async function exchangeCodeForToken(baseUrl, code, codeVerifier) {
-    return fetch(`${baseUrl}/cli/token`, {
+async function exchangeCodeForToken(webBaseUrl, code, codeVerifier) {
+    return fetch(`${webBaseUrl}/cli/token`, {
         method: "POST",
         headers: { "Content-Type": "application/x-www-form-urlencoded" },
         body: new URLSearchParams({ code, code_verifier: codeVerifier }),