@get-dx/cli 0.4.0 → 0.5.1

package/dist/cli.js

@@ -11,6 +11,7 @@ import { workflowsCommand } from "./commands/workflows.js";
 import { handleError } from "./commandHelpers.js";
 import cliPackage from "../package.json" with { type: "json" };
 import { handleTemporaryBaseUrlMigration } from "./config.js";
+import { checkForNewVersion, performUpdate, promptVersionUpdate, } from "./versionCheck.js";
 export async function run(argv = process.argv) {
     try {
         handleTemporaryBaseUrlMigration(argv);
@@ -19,7 +20,20 @@ export async function run(argv = process.argv) {
             program.outputHelp();
             return;
         }
+        let versionCheckResult = { shouldUpdate: false };
+        try {
+            const versionStatus = await checkForNewVersion(argv);
+            if (versionStatus.status === "available") {
+                versionCheckResult = await promptVersionUpdate(versionStatus.latestVersion);
+            }
+        }
+        catch {
+            // Never let a failure with version check or upgrade prompt block a command
+        }
         await program.parseAsync(argv);
+        if (versionCheckResult.shouldUpdate && versionCheckResult.latestVersion) {
+            await performUpdate(versionCheckResult.latestVersion);
+        }
     }
     catch (error) {
         handleError(error, undefined, argv);

package/dist/commands/auth.js

@@ -2,7 +2,7 @@ import { password, select } from "@inquirer/prompts";
 import { Command } from "commander";
 import { deleteToken, setToken } from "../secrets.js";
 import { renderJson } from "../renderers.js";
-import { renderAuthInfo, renderLoggedOut } from "./authRendering.js";
+import { renderAuthInfo, renderAuthWhoami, renderLoggedOut, } from "./authRendering.js";
 import { createExampleText, getContext, wrapAction, } from "../commandHelpers.js";
 import { persistBaseUrls, resolveApiBaseUrl, deriveBaseUrlsFromEnv, } from "../config.js";
 import { CliError } from "../errors.js";
@@ -51,12 +51,12 @@ export function authCommand() {
             }
             else {
                 token = await password({
-                    message: "Paste your account web API token here:",
+                    message: "Paste your personal access token or organization token here:",
                     mask: true,
                 });
             }
             if (!token) {
-                throw new CliError("Account web API token or personal access token is required");
+                throw new CliError("Personal access token or organization token is required");
             }
         }
         const runtime = await buildRuntime(context, {
@@ -128,6 +128,29 @@ export function authCommand() {
             renderAuthInfo(response, runtime.token, runtime.apiBaseUrl);
         }
     }));
+    auth
+        .command("whoami")
+        .description("Show user and team details for the authenticated token")
+        .addHelpText("afterAll", createExampleText([
+        {
+            label: "Fetch user and team details",
+            command: "dx auth whoami",
+        },
+        {
+            label: "Fetch user and team details as JSON",
+            command: "dx auth whoami --json",
+        },
+    ]))
+        .action(wrapAction(async (_options, command) => {
+        const runtime = await buildRuntime(getContext(command));
+        const response = await getAuthWhoami(runtime);
+        if (runtime.context.json) {
+            renderJson(response);
+        }
+        else {
+            renderAuthWhoami(response);
+        }
+    }));
     return auth;
 }
 // TODO: should we move this somewhere more central, since `init` needs it?
@@ -137,3 +160,9 @@ export async function getAuthInfo(runtime) {
     });
     return response.body;
 }
+export async function getAuthWhoami(runtime) {
+    const response = await request(runtime, "/auth.whoami", {
+        method: "GET",
+    });
+    return response.body;
+}

package/dist/commands/authRendering.js

@@ -37,10 +37,51 @@ function scopesContent(scopes) {
         ];
     }
 }
+export function renderAuthWhoami(response) {
+    const blocks = [];
+    // Auth section
+    blocks.push(ui.h3("Auth"));
+    blocks.push(ui.dl([
+        ui.dli("Account", response.account.name),
+        ui.dli("Token type", tokenTypeName(response.auth_token_type)),
+    ], { termWidth: 12 }));
+    // User section
+    blocks.push(ui.h3("Current user"));
+    if (response.user) {
+        blocks.push(ui.dl([
+            ui.dli("ID", ui.code(response.user.id)),
+            ui.dli("Name", response.user.name),
+            ui.dli("Email", response.user.email),
+        ], { termWidth: 7 }));
+    }
+    else {
+        blocks.push(ui.p(ui.dim("Not available for organization tokens")));
+    }
+    // Team section
+    blocks.push(ui.h3("Team"));
+    if (response.team) {
+        blocks.push(ui.dl([
+            ui.dli("ID", ui.code(response.team.id)),
+            ui.dli("Name", response.team.name),
+            ui.dli("Lead", formatUser(response.team.lead)),
+        ], { termWidth: 6 }));
+        if (response.team.contributors.length > 0) {
+            blocks.push(ui.p(ui.bold("Contributors:"), false));
+            blocks.push(ui.ul(response.team.contributors.map((c) => ui.li(formatUser(c)))));
+        }
+    }
+    else {
+        blocks.push(ui.p(ui.dim("Not available for organization tokens")));
+    }
+    renderRichText(blocks);
+}
+function formatUser(user) {
+    return `${user.name} ${ui.dim(`(${user.id}, ${user.email})`)}`;
+}
 function tokenTypeName(tokenType) {
     switch (tokenType) {
         case "account_web_api_token":
-            return "Account-level web API token";
+            return "Organization token";
         case "personal_access_token":
             return "Personal access token";
         default:

package/dist/commands/init.js

@@ -1,6 +1,3 @@
-import { access } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join } from "node:path";
 import { password, confirm, select } from "@inquirer/prompts";
 import { Command } from "commander";
 import { execa } from "execa";
@@ -13,6 +10,7 @@ import { renderRichText } from "../renderers.js";
 import * as ui from "../ui.js";
 import { CliError } from "../errors.js";
 import { deriveBaseUrlsFromEnv, persistBaseUrls } from "../config.js";
+import { isSkillInstalled } from "../skill.js";
 import { setToken } from "../secrets.js";
 import { renderWelcomeAnimation } from "../welcomeAnimation.js";
 export function initCommand() {
@@ -85,12 +83,12 @@ async function attemptLogin(apiBaseUrl, webBaseUrl, context) {
     }
     else {
         token = await password({
-            message: "Paste your account web API token here:",
+            message: "Paste your personal access token or organization token here:",
             mask: true,
         });
     }
     if (!token) {
-        throw new CliError("Account web API token is required");
+        throw new CliError("Personal access token or organization token is required");
     }
     const runtime = await buildRuntime(context, {
         apiBaseUrl,
@@ -113,10 +111,7 @@ async function optionallySetupSkill(runtime) {
         ui.h1(`Checking for the DX skill...`),
         ui.blankLine(),
     ]);
-    const skillPath = join(homedir(), ".agents", "skills", "dx-cli");
-    const skillInstalled = await access(skillPath)
-        .then(() => true)
-        .catch(() => false);
+    const skillInstalled = await isSkillInstalled();
     if (skillInstalled) {
         renderRichText([ui.p(`The DX skill is already installed.`)]);
         runtime.logger.debug("To update: npx skills update dx-cli --global");

package/dist/config.js

@@ -15,17 +15,36 @@ export function readConfig() {
     }
     const content = fs.readFileSync(configPath, "utf8");
     const raw = JSON.parse(content);
-    const api = raw.apiBaseUrl;
-    const web = raw.webBaseUrl;
     const stored = {};
-    if (web) {
-        stored.webBaseUrl = web;
+    if (typeof raw.webBaseUrl === "string") {
+        stored.webBaseUrl = raw.webBaseUrl;
+    }
+    if (typeof raw.apiBaseUrl === "string") {
+        stored.apiBaseUrl = raw.apiBaseUrl;
+    }
+    if (raw.currentVersionCache && typeof raw.currentVersionCache === "object") {
+        stored.currentVersionCache = raw.currentVersionCache;
     }
-    if (api) {
-        stored.apiBaseUrl = api;
+    if (raw.versionPromptSelection &&
+        typeof raw.versionPromptSelection === "object") {
+        stored.versionPromptSelection =
+            raw.versionPromptSelection;
     }
     return stored;
 }
+export function persistCurrentVersionCache(cache) {
+    writeConfig({ ...readConfig(), currentVersionCache: cache });
+}
+export function persistVersionPromptSelection(prompt) {
+    const config = readConfig();
+    if (prompt === undefined) {
+        delete config.versionPromptSelection;
+    }
+    else {
+        config.versionPromptSelection = prompt;
+    }
+    writeConfig(config);
+}
 /**
  * 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.

package/dist/skill.js

@@ -0,0 +1,9 @@
+import { access } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+export async function isSkillInstalled() {
+    const skillPath = join(homedir(), ".agents", "skills", "dx-cli");
+    return access(skillPath)
+        .then(() => true)
+        .catch(() => false);
+}

package/dist/versionCheck.js

@@ -0,0 +1,203 @@
+import { select } from "@inquirer/prompts";
+import dayjs from "dayjs";
+import { execa } from "execa";
+import { persistCurrentVersionCache, persistVersionPromptSelection, readConfig, } from "./config.js";
+import { request } from "./http.js";
+import { renderRichText } from "./renderers.js";
+import { buildRuntimeSafe } from "./runtime.js";
+import { isSkillInstalled } from "./skill.js";
+import * as ui from "./ui.js";
+import cliPackage from "../package.json" with { type: "json" };
+const VERSION_CHECK_INTERVAL_HOURS = 24;
+const SNOOZE_DAYS = 7;
+const SKIP_COMMANDS = new Set(["auth", "init"]);
+/**
+ * Compares two semver strings (e.g. "1.2.3").
+ * Returns a negative number if a < b, 0 if equal, positive if a > b.
+ */
+export function compareVersions(a, b) {
+    const parse = (v) => v.split(".").map((n) => parseInt(n, 10));
+    const [aMajor = 0, aMinor = 0, aPatch = 0] = parse(a);
+    const [bMajor = 0, bMinor = 0, bPatch = 0] = parse(b);
+    return aMajor - bMajor || aMinor - bMinor || aPatch - bPatch;
+}
+/**
+ * Returns true if a version fetch should be attempted — i.e. no cached result
+ * exists or the cached result is older than VERSION_CHECK_INTERVAL_HOURS.
+ */
+export function shouldPerformVersionCheck(config) {
+    const cache = config.currentVersionCache;
+    if (!cache?.updatedAt) {
+        return true;
+    }
+    const age = dayjs().diff(dayjs(cache.updatedAt), "hour");
+    return age >= VERSION_CHECK_INTERVAL_HOURS;
+}
+/**
+ * Returns true if the upgrade prompt should be shown to the user, taking into
+ * account any previously persisted SKIP or SNOOZE state.
+ */
+export function shouldShowVersionPrompt(latestVersion, versionPromptSelection) {
+    if (!versionPromptSelection) {
+        return true;
+    }
+    if (versionPromptSelection.type === "SKIP" &&
+        versionPromptSelection.skipVersion === latestVersion) {
+        return false;
+    }
+    if (versionPromptSelection.type === "SNOOZE" &&
+        dayjs().isBefore(dayjs(versionPromptSelection.snoozeUntil))) {
+        return false;
+    }
+    return true;
+}
+async function fetchLatestVersion(runtime) {
+    const response = await request(runtime, "/cli.currentVersion", { method: "GET" });
+    return response.body.versions.cli;
+}
+/**
+ * Checks whether a newer CLI version is available.
+ *
+ * Returns:
+ *   "available"  — a newer version exists and the user should be prompted
+ *   "up-to-date" — the installed version is current (or the user has snoozed/skipped)
+ *   "disabled"   — the check was skipped or could not run (env var, skip command, no token, network error)
+ */
+export async function checkForNewVersion(argv) {
+    if (process.env.DX_DISABLE_VERSION_CHECK) {
+        return { status: "disabled" };
+    }
+    const topLevelCommand = argv.slice(2).find((arg) => !arg.startsWith("-"));
+    if (topLevelCommand && SKIP_COMMANDS.has(topLevelCommand)) {
+        return { status: "disabled" };
+    }
+    const context = {
+        json: argv.includes("--json"),
+        agent: undefined,
+        agentSessionId: undefined,
+    };
+    const runtime = await buildRuntimeSafe(context);
+    if (!runtime) {
+        return { status: "disabled" };
+    }
+    const config = readConfig();
+    let latestVersion;
+    if (!shouldPerformVersionCheck(config)) {
+        latestVersion = config.currentVersionCache.contents.cli;
+    }
+    else {
+        try {
+            latestVersion = await fetchLatestVersion(runtime);
+        }
+        catch {
+            return { status: "disabled" };
+        }
+        persistCurrentVersionCache({
+            updatedAt: new Date().toISOString(),
+            contents: { cli: latestVersion },
+        });
+    }
+    if (compareVersions(latestVersion, cliPackage.version) <= 0) {
+        return { status: "up-to-date" };
+    }
+    if (!shouldShowVersionPrompt(latestVersion, readConfig().versionPromptSelection)) {
+        return { status: "up-to-date" };
+    }
+    return { status: "available", latestVersion };
+}
+/**
+ * Notifies the user that a new version is available and, in interactive
+ * sessions, prompts them to update, snooze, or skip.
+ *
+ * Returns a result indicating whether the user chose to update immediately,
+ * so the caller can invoke performUpdate() after the command finishes.
+ */
+export async function promptVersionUpdate(latestVersion) {
+    const noUpdate = { shouldUpdate: false };
+    const currentVersion = cliPackage.version;
+    const isInteractive = process.stdin.isTTY && process.stderr.isTTY;
+    if (!isInteractive) {
+        renderRichText([
+            ui.blankLine(),
+            ui.p(ui.warning(`A new version of the DX CLI is available: ${currentVersion} → ${latestVersion}`)),
+            ui.p(`Run: ${ui.code(`npm install -g @get-dx/cli@${latestVersion}`)}`),
+            ui.blankLine(),
+        ], { useStderr: true });
+        return noUpdate;
+    }
+    renderRichText([
+        ui.blankLine(),
+        ui.p(ui.warning(`A new version of the DX CLI is available: ${currentVersion} → ${latestVersion}`)),
+        ui.blankLine(),
+    ], { useStderr: true });
+    const choice = await select({
+        message: "What would you like to do?",
+        choices: [
+            { name: "Update now", value: "update" },
+            { name: `Remind me later (in ${SNOOZE_DAYS} days)`, value: "snooze" },
+            { name: "Skip this version", value: "skip" },
+        ],
+    });
+    if (choice === "update") {
+        persistVersionPromptSelection(undefined);
+        return { shouldUpdate: true, latestVersion };
+    }
+    if (choice === "snooze") {
+        persistVersionPromptSelection({
+            type: "SNOOZE",
+            snoozeUntil: dayjs().add(SNOOZE_DAYS, "day").toISOString(),
+        });
+    }
+    else {
+        persistVersionPromptSelection({ type: "SKIP", skipVersion: latestVersion });
+    }
+    return noUpdate;
+}
+/**
+ * Performs the actual CLI + skill upgrade after the user's command has finished.
+ */
+export async function performUpdate(latestVersion) {
+    if (await isSkillInstalled()) {
+        renderRichText([
+            ui.blankLine(),
+            ui.p(ui.bold("Updating the DX skill.")),
+            ui.p("This will run the following command:", false),
+            ui.codeBlock("npx --yes -- skills@latest update dx-cli --global"),
+            ui.blankLine(),
+        ], {
+            useStderr: true,
+        });
+        try {
+            await execa({
+                stdout: "inherit",
+                stderr: "inherit",
+                stdin: "inherit",
+            }) `npx --yes -- skills@latest update dx-cli --global`;
+        }
+        catch {
+            renderRichText([
+                ui.p(ui.warning("Warning: failed to update the DX skill. You can update it manually with: " +
+                    ui.code("npx skills update dx-cli --global"))),
+            ], { useStderr: true });
+        }
+    }
+    renderRichText([
+        ui.blankLine(),
+        ui.p(ui.bold(`Updating the DX CLI to ${latestVersion}.`)),
+        ui.p("This will run the following command:", false),
+        ui.codeBlock(`npm install -g @get-dx/cli@${latestVersion}`),
+        ui.blankLine(),
+    ], { useStderr: true });
+    try {
+        await execa({
+            stdout: "inherit",
+            stderr: "inherit",
+        }) `npm install -g @get-dx/cli@${latestVersion}`;
+    }
+    catch {
+        renderRichText([
+            ui.p(ui.warning(`Warning: failed to update the DX CLI. You can update it manually with: ` +
+                ui.code(`npm install -g @get-dx/cli@${latestVersion}`))),
+        ], { useStderr: true });
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@get-dx/cli",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "description": "DX CLI",
   "author": "DX <developers@getdx.com>",
   "bugs": {