@zeroheight/adoption-cli 0.4.4 → 1.2.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Release notes
 
+## [1.2.0](https://www.npmjs.com/package/@zeroheight/adoption-cli/v/1.2.0) - 17th October 2024
+- Support scoped packages in Yarn lockfiles
+
+## [1.1.0](https://www.npmjs.com/package/@zeroheight/adoption-cli/v/1.1.0) - 17th October 2024
+- Validate authentication credentials on set up
+
+## [1.0.0](https://www.npmjs.com/package/@zeroheight/adoption-cli/v/1.0.0) - 16th October 2024
+
+New! Package adoption can now be tracked from the CLI
+
+- Keep track of the latest version of your packages
+- Understand which version of packages your repositories are using
+
+## [0.4.5](https://www.npmjs.com/package/@zeroheight/adoption-cli/v/0.4.5) - 23rd September 2024
+
+- Fix URL generated when using a token associated with a workspaces account
+
 ## [0.4.4](https://www.npmjs.com/package/@zeroheight/adoption-cli/v/0.4.4) - 17th September 2024
 
 - Bug fixes
@@ -36,32 +53,42 @@
 - Stop the flow breaking due to parsing errors
 
 ## [0.2.12](https://www.npmjs.com/package/@zeroheight/adoption-cli/v/0.2.12) - 24th July 2024
+
 - Update release notes
 
 ## [0.2.11](https://www.npmjs.com/package/@zeroheight/adoption-cli/v/0.2.11) - 24th July 2024
+
 - Add accessible release notes
 
 ## [0.2.10](https://www.npmjs.com/package/@zeroheight/adoption-cli/v/0.2.10) - 15th July 2024
+
 - Add ability to reset authentication credentials
 
 ## [0.2.9](https://www.npmjs.com/package/@zeroheight/adoption-cli/v/0.2.9) - 20th June 2024
+
 - Update documentation links
 
 ## [0.2.8](https://www.npmjs.com/package/@zeroheight/adoption-cli/v/0.2.8) - 19th June 2024
+
 - Bug fixes
 
 ## [0.2.7](https://www.npmjs.com/package/@zeroheight/adoption-cli/v/0.2.7) - 19th June 2024
+
 - Bug fixes
 
 ## [0.2.6](https://www.npmjs.com/package/@zeroheight/adoption-cli/v/0.2.6) - 19th June 2024
+
 - Bug fixes
 
 ## [0.2.5](https://www.npmjs.com/package/@zeroheight/adoption-cli/v/0.2.5) - 14th June 2024
+
 - Add more support for TypeScript files
 - Allow `--ignore` to be passed as an option
 
 ## [0.2.0](https://www.npmjs.com/package/@zeroheight/adoption-cli/v/0.2.0) - 10th June 2024
+
 - Add ability to define name of repository being analyzed
 
 ## [0.1.1](https://www.npmjs.com/package/@zeroheight/adoption-cli/v/0.1.1) - 3rd June 2024
+
 - Initial package set up

package/README.md

@@ -12,6 +12,29 @@ npm i @zeroheight/adoption-cli
 
 ## Usage
 
+### Authentication
+
+#### Interactive mode
+
+When running a command, you will be prompted to authenticate. This will save the Client ID and Access Token to your local machine.
+
+Alternatively, you can authenticate by running the following command:
+
+```
+zh-adoption auth
+```
+
+#### Non-interactive mode
+
+When running a command with the `--interactive false` flag, you will need to provide the Client ID and Access Token as environment variables.
+
+```bash
+export ZEROHEIGHT_CLIENT_ID="your-client-id"
+export ZEROHEIGHT_ACCESS_TOKEN="your-access-token"
+```
+
+---
+
 ### Component usage analysis
 
 In the repository in which you wish to analyze the component usage, run the following command:
@@ -54,28 +77,44 @@ Pass in `false` to disable the interactive mode e.g. when running in a CI enviro
 zh-adoption analyze --interactive false -r "My Repo"
 ```
 
+---
+
+### Monitor repo
 
+In the repository in which you wish to monitor the package versions being used, run the following command:
 
-To send adoption data to your [zeroheight](https://zeroheight.com/) account you will need to authenticate using a Client ID and Access Token.
+```bash
+zh-adoption monitor-repo
+```
 
-### Authentication
-#### Interactive mode
+#### Options
 
-When running the `analyze` command, you will be prompted to authenticate. This will save the Client ID and Access Token to your local machine.
+`-d` / `--dir`
 
-Alternatively, you can authenticate by running the following command:
+Provide a path to the specific folder to find package.json and lock file. This option can be passed through multiple times. If not included all folders with package.json and lockfile will be uploaded to zeroheight.
 
+```bash
+zh-adoption monitor-repo -d ./webApp
 ```
-zh-adoption auth
+
+---
+
+### Track package
+
+In the repository containing the packages you wish to monitor the version of, run the following command:
+
+```bash
+zh-adoption track-package
 ```
 
-#### Non-interactive mode
+#### Options
 
-When running the `analyze` command with the `--interactive false` flag, you will need to provide the Client ID and Access Token as environment variables.
+`-in` / `--interactive`
+
+Pass in `false` to disable the interactive mode e.g. when running in a CI environment.
 
 ```bash
-export ZEROHEIGHT_CLIENT_ID="your-client-id"
-export ZEROHEIGHT_ACCESS_TOKEN="your-access-token"
+zh-adoption track-package --interactive false
 ```
 
 ---

package/dist/cli.js

@@ -5,17 +5,19 @@ import { render } from "ink-render-string";
 import HelpInfo from "./components/help-info.js";
 import { analyzeCommand } from "./commands/analyze.js";
 import { authCommand } from "./commands/auth.js";
-// import { trackPackageCommand } from "./commands/track-package.js";
+import { monitorRepoCommand } from "./commands/monitor-repo.js";
+import { trackPackageCommand } from "./commands/track-package.js";
 const program = new Command();
 const { output, cleanup } = render(React.createElement(HelpInfo, null));
 program
     .name("zh-adoption")
     .description("CLI for measuring design system usage usage in your products")
-    .version("0.4.4")
+    .version("1.2.0")
     .addHelpText("before", output)
     .addCommand(analyzeCommand())
-    .addCommand(authCommand());
-// .addCommand(trackPackageCommand());
+    .addCommand(authCommand())
+    .addCommand(monitorRepoCommand())
+    .addCommand(trackPackageCommand());
 cleanup();
 // Only start parsing if run as CLI, don't start parsing during testing
 if (process.env["NODE_ENV"] !== "test") {

package/dist/commands/monitor-repo.d.ts

@@ -0,0 +1,9 @@
+import { Command } from "commander";
+import { RenderOptions } from "ink";
+interface MonitorRepoOptions {
+    interactive: boolean;
+    dir?: string[];
+}
+export declare function monitorRepoAction(options: MonitorRepoOptions, _renderOptions?: RenderOptions): Promise<void>;
+export declare function monitorRepoCommand(): Command;
+export {};

package/dist/commands/monitor-repo.js

@@ -0,0 +1,36 @@
+import * as React from "react";
+import { Command, Option } from "commander";
+import { render } from "ink";
+// import yn from "yn";
+import NonInteractiveMonitorRepo from "../components/monitor-repo/non-interactive-monitor-repo.js";
+export async function monitorRepoAction(options, _renderOptions) {
+    // if (options.interactive) {
+    //   render(<MonitorRepo />, renderOptions);
+    // } else {
+    render(React.createElement(NonInteractiveMonitorRepo, { packageDirs: options.dir }));
+    // }
+}
+export function monitorRepoCommand() {
+    const command = new Command();
+    return (command
+        .command("monitor-repo")
+        .description("Monitor package usage in a repository")
+        // .addOption(
+        //   new Option(
+        //     "-in, --interactive [boolean]",
+        //     "disable to skip manual input (useful when running in CI)"
+        //   )
+        //     .default(true)
+        //     .argParser((value) => yn(value))
+        // )
+        .addOption(new Option("-d, --dir <path...>", "use package directory to find package.json and lockfile"))
+        .action(async (options) => {
+        try {
+            await monitorRepoAction(options);
+        }
+        catch (e) {
+            console.error(e);
+            process.exitCode = 1;
+        }
+    }));
+}

package/dist/commands/monitor-repo.utils.d.ts

@@ -0,0 +1,31 @@
+import NPMLockParser from "../lockfile-parsers/npm-lock-parser.js";
+import PNPMLockParser from "../lockfile-parsers/pnpm-lock-parser.js";
+import YarnLockParser from "../lockfile-parsers/yarn-lock-parser.js";
+/**
+ * Group a list of paths by the directory
+ */
+export declare function groupByBasename(paths: string[]): Record<string, string[]>;
+/**
+ * Retrieve name and version from a package.json filepath
+ */
+export declare function getPackageMeta(packageFile: string): Promise<{
+    name: string;
+    version: string;
+}>;
+export declare function parseLockfile(lockfilePath: string): Promise<NPMLockParser | PNPMLockParser | YarnLockParser>;
+/**
+ * Find the lock file based on known lock file names
+ * @param subpath - provide to search inside subpath instead of working directory
+ */
+export declare function findLockfiles(subpath?: string): Promise<string[]>;
+/**
+ * Get the lockfile parser so name, version and packages can be extracted from the lockfile
+ *
+ * @param filename the lockfile name
+ * @returns the parser to use or null if unrecognized
+ */
+export declare function getLockParserForFile(filename: string): typeof NPMLockParser | typeof PNPMLockParser | typeof YarnLockParser | null;
+/**
+ * Get the type of lockfile given the name
+ */
+export declare function getParserTypeFromFileName(filename: string): "yarn" | "npm" | "pnpm" | null;

package/dist/commands/monitor-repo.utils.js

@@ -0,0 +1,81 @@
+import { readFile } from "fs/promises";
+import { basename, dirname, join as joinPath } from "path";
+import { findFiles } from "./analyze.utils.js";
+import NPMLockParser from "../lockfile-parsers/npm-lock-parser.js";
+import PNPMLockParser from "../lockfile-parsers/pnpm-lock-parser.js";
+import YarnLockParser from "../lockfile-parsers/yarn-lock-parser.js";
+/**
+ * Group a list of paths by the directory
+ */
+export function groupByBasename(paths) {
+    return paths
+        .map((p) => {
+        return { base: dirname(p), filename: basename(p) };
+    })
+        .reduce((acc, pathObj) => {
+        acc[pathObj.base] = [...(acc[pathObj.base] ?? []), pathObj.filename];
+        return acc;
+    }, {});
+}
+/**
+ * Retrieve name and version from a package.json filepath
+ */
+export async function getPackageMeta(packageFile) {
+    const packageContents = await readFile(packageFile, "utf-8");
+    const packageData = JSON.parse(packageContents);
+    return { name: packageData.name, version: packageData.version };
+}
+export async function parseLockfile(lockfilePath) {
+    const lockfileName = basename(lockfilePath);
+    const ParserClass = getLockParserForFile(lockfileName);
+    if (!ParserClass) {
+        throw new Error(`Can\'t find parser for ${lockfileName}`);
+    }
+    const fileContents = await readFile(lockfilePath, "utf-8");
+    return new ParserClass(fileContents);
+}
+/**
+ * Find the lock file based on known lock file names
+ * @param subpath - provide to search inside subpath instead of working directory
+ */
+export async function findLockfiles(subpath) {
+    const workingDir = joinPath(process.cwd(), subpath ?? "");
+    return findFiles(workingDir, "**/**/{package-lock.json,shrinkwrap.yaml,pnpm-lock.yaml,yarn.lock}", "");
+}
+/**
+ * Get the lockfile parser so name, version and packages can be extracted from the lockfile
+ *
+ * @param filename the lockfile name
+ * @returns the parser to use or null if unrecognized
+ */
+export function getLockParserForFile(filename) {
+    switch (filename) {
+        case "yarn.lock":
+            return YarnLockParser;
+        case "package-lock.json":
+            return NPMLockParser;
+        case "pnpm-lock.yaml":
+            return PNPMLockParser;
+        case "shrinkwrap.yaml":
+            return PNPMLockParser;
+        default:
+            return null;
+    }
+}
+/**
+ * Get the type of lockfile given the name
+ */
+export function getParserTypeFromFileName(filename) {
+    switch (filename) {
+        case "yarn.lock":
+            return "yarn";
+        case "package-lock.json":
+            return "npm";
+        case "pnpm-lock.yaml":
+            return "pnpm";
+        case "shrinkwrap.yaml":
+            return "pnpm";
+        default:
+            return null;
+    }
+}

package/dist/commands/track-package.d.ts

@@ -1,4 +1,8 @@
 import { Command } from "commander";
 import { RenderOptions } from "ink";
-export declare function trackPackageAction(renderOptions?: RenderOptions): Promise<void>;
+interface TrackPackageOptions {
+    interactive: boolean;
+}
+export declare function trackPackageAction(options: TrackPackageOptions, renderOptions?: RenderOptions): Promise<void>;
 export declare function trackPackageCommand(): Command;
+export {};

package/dist/commands/track-package.js

@@ -1,18 +1,28 @@
 import * as React from "react";
-import { Command } from "commander";
+import { Command, Option } from "commander";
 import { render } from "ink";
+import yn from "yn";
+import NonInteractiveTrackPackage from "../components/track-package/non-interactive-track-package.js";
 import TrackPackage from "../components/track-package/track-package.js";
-export async function trackPackageAction(renderOptions) {
-    render(React.createElement(TrackPackage, null), renderOptions);
+export async function trackPackageAction(options, renderOptions) {
+    if (options.interactive) {
+        render(React.createElement(TrackPackage, null), renderOptions);
+    }
+    else {
+        render(React.createElement(NonInteractiveTrackPackage, null));
+    }
 }
 export function trackPackageCommand() {
     const command = new Command();
     return command
         .command("track-package")
         .description("Track the latest version of your package in zeroheight")
-        .action(async () => {
+        .addOption(new Option("-in, --interactive [boolean]", "disable to skip manual input (useful when running in CI)")
+        .default(true)
+        .argParser((value) => yn(value)))
+        .action(async (options) => {
         try {
-            await trackPackageAction();
+            await trackPackageAction(options);
         }
         catch (e) {
             console.error(e);

package/dist/commands/track-package.utils.d.ts

@@ -1,16 +1,10 @@
+import { PackageFile } from "../common/types/package-file.js";
+/**
+ * Find the package.json file
+ * @param subpath - provide to search inside subpath instead of working directory
+ */
+export declare function findPackageFiles(subpath?: string): Promise<string[]>;
 export declare function getPackageInfo(): Promise<{
-    name: null;
-    path: null;
-    version: null;
-    error: string;
-} | {
-    name: any;
-    path: string;
-    version: any;
-    error: null;
-} | {
-    name: null;
-    path: string;
-    version: null;
-    error: string;
+    files: PackageFile[];
+    error: string | null;
 }>;

package/dist/commands/track-package.utils.js

@@ -1,32 +1,41 @@
 import { readFile } from "fs/promises";
+import { join as joinPath } from "path";
 import { findFiles } from "./analyze.utils.js";
+/**
+ * Find the package.json file
+ * @param subpath - provide to search inside subpath instead of working directory
+ */
+export async function findPackageFiles(subpath) {
+    const workingDir = joinPath(process.cwd(), subpath ?? "");
+    return findFiles(workingDir, "**/**/package.json", "");
+}
 export async function getPackageInfo() {
     const base = process.cwd();
-    const files = await findFiles(base, "**/**/package.json", "");
+    const files = await findPackageFiles();
     if (files.length === 0) {
         return {
-            name: null,
-            path: null,
-            version: null,
-            error: "Can't find any package files"
+            files: [],
+            error: "Can't find any package files",
         };
     }
-    const relativeBase = `.${files[0]?.split(base).pop()}`;
     try {
-        const fileContents = await readFile(files[0], "utf-8");
+        const packageFiles = await Promise.all(files.map(async (file) => {
+            const fileContents = await readFile(file, "utf-8");
+            return {
+                name: JSON.parse(fileContents).name,
+                path: `.${files[0]?.split(base).pop()}`,
+                version: JSON.parse(fileContents).version,
+            };
+        }));
         return {
-            name: JSON.parse(fileContents).name,
-            path: relativeBase,
-            version: JSON.parse(fileContents).version,
-            error: null
+            files: packageFiles,
+            error: null,
         };
     }
     catch {
         return {
-            name: null,
-            path: relativeBase,
-            version: null,
-            error: `Can't parse file ${files[0]}`
+            files: [],
+            error: `Can't parse file ${files[0]}`,
         };
     }
 }

package/dist/common/api.d.ts

@@ -1,6 +1,34 @@
 import { RawUsageMap } from "../commands/analyze.js";
 import { Credentials } from "./config.js";
+/**
+ * Open API V2 Response format
+ */
+interface APIResponse<T> {
+    status: string;
+    message: string;
+    data: T;
+}
 export declare function getZeroheightURL(): URL;
-export declare function submitPackageDetails(name: string, path: string, version: string, credentials: Credentials): Promise<any>;
+export declare function submitPackageDetails(name: string, path: string, version: string, credentials: Credentials): Promise<APIResponse<any>>;
+export declare function submitMonitoredRepoDetails(name: string, version: string, lockfilePath: string, packages: {
+    name: string;
+    version: string;
+}[], credentials: Credentials): Promise<APIResponse<{
+    errors: string[];
+}>>;
 export declare function submitUsageData(usage: RawUsageMap, repoName: string, credentials: Credentials): Promise<any>;
-export declare function getExistingRepoNames(credentials: Credentials): Promise<any>;
+export declare function getExistingRepoNames(credentials: Credentials): Promise<string[]>;
+interface AuthTokensResponse {
+    scopes: string[];
+    email: string;
+    project: {
+        id: number;
+        name: string;
+    } | null;
+    team: {
+        id: number;
+        name: string;
+    };
+}
+export declare function getAuthDetails(credentials: Credentials): Promise<AuthTokensResponse>;
+export {};

package/dist/common/api.js

@@ -13,6 +13,14 @@ export async function submitPackageDetails(name, path, version, credentials) {
         latest_version: version,
     }, credentials);
 }
+export async function submitMonitoredRepoDetails(name, version, lockfilePath, packages, credentials) {
+    return post("/open_api/v2/monitored_repositories", {
+        name,
+        lock_file_path: lockfilePath,
+        packages,
+        version,
+    }, credentials);
+}
 export async function submitUsageData(usage, repoName, credentials) {
     return post("/open_api/v1/component_usages", {
         repo_name: repoName,
@@ -22,6 +30,10 @@ export async function submitUsageData(usage, repoName, credentials) {
 export function getExistingRepoNames(credentials) {
     return get("/open_api/v1/component_usages/repo_names", credentials);
 }
+export async function getAuthDetails(credentials) {
+    const response = await get("/open_api/v2/auth_tokens", credentials);
+    return response.data;
+}
 async function get(path, credentials) {
     return request(path, credentials, {
         method: "GET",
@@ -42,7 +54,7 @@ async function request(path, credentials, init) {
     const response = await fetch(url, {
         ...init,
         headers: {
-            "X-API-CLIENT-NAME": 'cli',
+            "X-API-CLIENT-NAME": "cli",
             "X-API-CLIENT": credentials.client,
             "X-API-KEY": credentials.token,
             "Content-Type": "application/json",

package/dist/common/types/package-file.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Sparse package.json interface, only containing properties we care about
+ */
+export interface PackageFile {
+    name: string;
+    path: string;
+    version: string;
+}

package/dist/common/types/package-file.js

@@ -0,0 +1 @@
+export {};

package/dist/components/analyze/analyze.js

@@ -8,7 +8,7 @@ import NoCredentialsOnboarding from "../auth/no-credentials-onboarding.js";
 import RepoNamePrompt from "../repo-name-prompt.js";
 import UsageTable from "../usage-table.js";
 import { configPath, writeConfig, readConfig, } from "../../common/config.js";
-import { getZeroheightURL, submitUsageData } from "../../common/api.js";
+import { getAuthDetails, getZeroheightURL, submitUsageData, } from "../../common/api.js";
 import { calculateNumberOfComponents } from "../../commands/analyze.utils.js";
 export default function Analyze({ onAnalyzeFiles, dryRun, repoName, }) {
     const { exit } = useApp();
@@ -49,8 +49,12 @@ export default function Analyze({ onAnalyzeFiles, dryRun, repoName, }) {
         setIsSendingData(true);
         try {
             await submitUsageData(result, repoName, credentials);
+            const authDetails = await getAuthDetails(credentials);
+            const projectId = authDetails.project?.id;
             const resourceURL = getZeroheightURL();
-            resourceURL.pathname = "/adoption/";
+            resourceURL.pathname = projectId
+                ? `/project/${projectId}/adoption/`
+                : "/adoption/";
             setResourceURL(resourceURL);
         }
         catch (e) {
@@ -94,6 +98,15 @@ export default function Analyze({ onAnalyzeFiles, dryRun, repoName, }) {
             setShowContinue(true);
         }
     }
+    async function handleCheckCredentials(newClient, newToken) {
+        try {
+            await getAuthDetails({ token: newToken, client: newClient });
+        }
+        catch {
+            setErrorList(["Auth credentials are not valid"]);
+            return exit();
+        }
+    }
     if (errorList.length > 0) {
         return (React.createElement(Box, { flexDirection: "column" },
             React.createElement(Text, { color: "red" }, "Error:"),
@@ -102,7 +115,7 @@ export default function Analyze({ onAnalyzeFiles, dryRun, repoName, }) {
                 e))))));
     }
     if (!promptRepo && !credentials && !dryRun) {
-        return (React.createElement(NoCredentialsOnboarding, { configPath: configPath(), onSaveCredentials: async (persist, newClient, newToken) => {
+        return (React.createElement(NoCredentialsOnboarding, { configPath: configPath(), onCheckCredentials: handleCheckCredentials, onSaveCredentials: async (persist, newClient, newToken) => {
                 const newCredentials = { token: newToken, client: newClient };
                 setCredentials(newCredentials);
                 if (persist) {

package/dist/components/auth/auth.js

@@ -1,4 +1,4 @@
-import { Box, Text } from "ink";
+import { Box, Text, useApp } from "ink";
 import React from "react";
 import ConfirmInput from "../ui/confirm-input.js";
 import NoCredentialsOnboarding from "./no-credentials-onboarding.js";
@@ -6,6 +6,7 @@ import { configPath, readConfig, writeConfig, } from "../../common/config.js";
 import CredentialsAlreadyExists from "./credentials-already-exists.js";
 import CredentialsPreview from "./credentials-preview.js";
 import Spinner from "ink-spinner";
+import { getAuthDetails } from "../../common/api.js";
 var Step;
 (function (Step) {
     Step[Step["LOADING_CONFIG"] = 0] = "LOADING_CONFIG";
@@ -14,8 +15,10 @@ var Step;
     Step[Step["DONE_WRITE_FAIL"] = 3] = "DONE_WRITE_FAIL";
     Step[Step["DONE_WRITE_SUCCESS"] = 4] = "DONE_WRITE_SUCCESS";
     Step[Step["DONE_NO_CHANGE"] = 5] = "DONE_NO_CHANGE";
+    Step[Step["DONE_AUTH_FAIL"] = 6] = "DONE_AUTH_FAIL";
 })(Step || (Step = {}));
 export default function Auth({ token, client }) {
+    const { exit } = useApp();
     const [shouldOverwriteAnswer, setShouldOverwriteAnswer] = React.useState("");
     const [existingConfig, setExistingConfig] = React.useState(null);
     const [currentStep, setCurrentStep] = React.useState(Step.LOADING_CONFIG);
@@ -64,6 +67,15 @@ export default function Auth({ token, client }) {
             setCurrentStep(Step.DONE_NO_CHANGE);
         }
     }
+    async function handleCheckCredentials(newClient, newToken) {
+        try {
+            await getAuthDetails({ token: newToken, client: newClient });
+        }
+        catch {
+            setCurrentStep(Step.DONE_AUTH_FAIL);
+            return exit();
+        }
+    }
     async function handleSaveCredentials(persist, newClient, newToken) {
         if (persist) {
             await mergeAndWriteConfig(existingConfig, newClient, newToken);
@@ -83,7 +95,7 @@ export default function Auth({ token, client }) {
                         React.createElement(Text, { dimColor: true }, "(y/N)")),
                     React.createElement(ConfirmInput, { isChecked: false, value: shouldOverwriteAnswer, onChange: setShouldOverwriteAnswer, onSubmit: handleSubmitOverwrite }))));
         case Step.PROMPT_NEW_CREDENTIALS:
-            return (React.createElement(NoCredentialsOnboarding, { onSaveCredentials: handleSaveCredentials, configPath: configPath() }));
+            return (React.createElement(NoCredentialsOnboarding, { onCheckCredentials: handleCheckCredentials, onSaveCredentials: handleSaveCredentials, configPath: configPath() }));
         case Step.DONE_WRITE_SUCCESS:
             return (React.createElement(Box, { flexDirection: "column" },
                 React.createElement(Text, { color: "green" }, "Updated credentials"),
@@ -94,6 +106,8 @@ export default function Auth({ token, client }) {
                 existingConfig?.client && existingConfig?.token && (React.createElement(CredentialsPreview, { client: existingConfig.client, token: existingConfig.token }))));
         case Step.DONE_WRITE_FAIL:
             return React.createElement(Text, { color: "yellow" }, "Something went wrong, try again.");
+        case Step.DONE_AUTH_FAIL:
+            return (React.createElement(Text, { color: "red" }, "Unable to authenticate. Please re-run the command to try again."));
         case Step.LOADING_CONFIG:
             return (React.createElement(Text, null,
                 React.createElement(Text, { color: "green" },

package/dist/components/auth/no-credentials-onboarding.d.ts

@@ -1,7 +1,8 @@
 import * as React from "react";
 interface NoCredentialsOnboardingProps {
+    onCheckCredentials: (client: string, token: string) => Promise<void>;
     onSaveCredentials: (storeCredentials: boolean, client: string, token: string) => Promise<void>;
     configPath: string;
 }
-export default function NoCredentialsOnboarding({ onSaveCredentials, configPath, }: NoCredentialsOnboardingProps): React.JSX.Element;
+export default function NoCredentialsOnboarding({ onCheckCredentials, onSaveCredentials, configPath, }: NoCredentialsOnboardingProps): React.JSX.Element;
 export {};