@crossmint/cli 1.1.2

package/src/commands/keys/delete.test.ts

@@ -0,0 +1,87 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { HttpMethods, routes } from "@crossmint/common-consts";
+import { fetchAuthenticated } from "@/utils/fetch";
+import { getProjectId } from "@/utils/store";
+import { confirm } from "@inquirer/prompts";
+import deleteKey from "./delete";
+import { createSpinner } from "@/utils/spinner";
+
+// Mock dependencies
+vi.mock("@/utils/fetch", () => ({
+    fetchAuthenticated: vi.fn(),
+}));
+
+vi.mock("@/utils/store", () => ({
+    getProjectId: vi.fn(),
+}));
+
+vi.mock("@inquirer/prompts", () => ({
+    confirm: vi.fn(),
+}));
+
+vi.mock("@/utils/spinner");
+
+describe("deleteKey", () => {
+    const mockProjectId = "test-project-id";
+    const mockKeyId = "test-key-id";
+
+    let spinner: any;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        (getProjectId as any).mockResolvedValue(mockProjectId);
+        (confirm as any).mockResolvedValue(true);
+        spinner = {
+            fail: vi.fn(),
+            succeed: vi.fn(),
+            start: vi.fn(),
+        };
+        (createSpinner as any).mockReturnValue(spinner);
+        vi.spyOn(console, "error");
+    });
+
+    it("should successfully delete an API key", async () => {
+        await deleteKey(mockKeyId);
+
+        // Verify getProjectId was called
+        expect(getProjectId).toHaveBeenCalled();
+
+        // Verify confirm was called with the correct message
+        expect(confirm).toHaveBeenCalledWith({
+            message: "Are you sure you want to delete this API key? This action cannot be undone.",
+            default: false,
+        });
+
+        // Verify fetchAuthenticated was called with the correct parameters
+        expect(fetchAuthenticated).toHaveBeenCalledWith(
+            routes.api.console.projects.apiKeys(mockProjectId, mockKeyId),
+            HttpMethods.DELETE
+        );
+    });
+
+    it("should exit if no project is selected", async () => {
+        (getProjectId as any).mockResolvedValue(null);
+
+        await expect(deleteKey(mockKeyId)).rejects.toThrow();
+        expect(console.error).toHaveBeenCalledWith(
+            "There is no project selected, please first run `crossmint project select`"
+        );
+        expect(process.exit).toHaveBeenCalledWith(1);
+    });
+
+    it("should exit if user cancels the operation", async () => {
+        (confirm as any).mockResolvedValueOnce(false);
+
+        await deleteKey(mockKeyId);
+        expect(spinner.fail).toHaveBeenCalledWith("Operation cancelled");
+        expect(process.exit).toHaveBeenCalledWith(0);
+    });
+
+    it("should handle delete error", async () => {
+        (fetchAuthenticated as any).mockRejectedValue(new Error("Delete failed"));
+
+        await expect(deleteKey(mockKeyId)).rejects.toThrow();
+        expect(spinner.fail).toHaveBeenCalledWith("❌ Failed to delete API key: Delete failed");
+        expect(process.exit).toHaveBeenCalledWith(1);
+    });
+});

package/src/commands/keys/delete.ts

@@ -0,0 +1,36 @@
+import { HttpMethods } from "@crossmint/common-consts";
+import { routes } from "@crossmint/common-consts";
+import { fetchAuthenticated } from "@/utils/fetch";
+import { getProjectId } from "@/utils/store";
+import { confirm } from "@inquirer/prompts";
+import { createSpinner } from "@/utils/spinner";
+
+export default async function deleteKey(keyId: string): Promise<void> {
+    const projectId = await getProjectId();
+    if (!projectId) {
+        console.error("There is no project selected, please first run `crossmint project select`");
+        process.exit(1);
+    }
+
+    const spinner = createSpinner("Deleting API key...");
+    try {
+        const confirmed = await confirm({
+            message: "Are you sure you want to delete this API key? This action cannot be undone.",
+            default: false,
+        });
+
+        if (!confirmed) {
+            spinner.fail("Operation cancelled");
+            process.exit(0);
+        }
+
+        spinner.start();
+
+        await fetchAuthenticated(routes.api.console.projects.apiKeys(projectId, keyId), HttpMethods.DELETE);
+
+        spinner.succeed("✅ API key deleted successfully!");
+    } catch (error) {
+        spinner.fail(`❌ Failed to delete API key: ${error instanceof Error ? error.message : "Unknown error"}`);
+        process.exit(1);
+    }
+}

package/src/commands/keys/edit.test.ts

@@ -0,0 +1,159 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { HttpMethods } from "@crossmint/common-consts";
+import { routes } from "@crossmint/common-consts";
+import { fetchAuthenticated } from "@/utils/fetch";
+import { getEnvironment, getProjectId } from "@/utils/store";
+import { checkbox } from "@inquirer/prompts";
+import editKey from "./edit";
+import { APIKeyDocument } from "@crossmint/products-console-types";
+import { getScopeChoices } from "@/utils/scopes";
+import { createSpinner } from "@/utils/spinner";
+import { getProject } from "@/utils/getProject";
+import { getWhitelistedOriginsAndAppIdentifiersPrompt } from "@/utils/getWhitelistedOriginsAndAppIdentifiersPrompt";
+
+vi.mock("@/utils/fetch", () => ({
+    fetchAuthenticated: vi.fn(),
+}));
+
+vi.mock("@/utils/store", () => ({
+    getProjectId: vi.fn(),
+    getEnvironment: vi.fn(),
+}));
+
+vi.mock("@inquirer/prompts", async (importOriginal) => ({
+    ...(await importOriginal()),
+    checkbox: vi.fn(),
+}));
+
+vi.mock("@/utils/getProject", () => ({
+    getProject: vi.fn(),
+}));
+
+vi.mock("@/utils/getWhitelistedOriginsAndAppIdentifiersPrompt", () => ({
+    getWhitelistedOriginsAndAppIdentifiersPrompt: vi.fn(),
+}));
+
+vi.mock("@/utils/spinner");
+
+describe("editKey", () => {
+    const mockProjectId = "test-project-id";
+    const mockKeyId = "test-key-id";
+    const mockKey: APIKeyDocument = {
+        _id: mockKeyId as any,
+        usageOrigin: "server",
+        projectId: mockProjectId as any,
+        clientId: "test-client-id",
+        clientSecret: "test-client-secret",
+        hashedSecret: "test-hashed-secret",
+        scopes: ["wallets.read"],
+        isDeleted: false,
+        createdAt: Date.now(),
+    };
+
+    let spinner: any;
+    const activeProject: any = {};
+    beforeEach(() => {
+        spinner = {
+            start: vi.fn(),
+            succeed: vi.fn(),
+            fail: vi.fn(),
+        };
+        vi.clearAllMocks();
+        vi.spyOn(console, "error").mockImplementation(() => {});
+        (getProjectId as any).mockResolvedValue(mockProjectId);
+        (fetchAuthenticated as any).mockResolvedValue([mockKey]);
+        (checkbox as any).mockResolvedValue(["wallets.read", "wallets.create"]);
+        (createSpinner as any).mockReturnValue(spinner);
+        (getEnvironment as any).mockResolvedValue("production");
+        (getProject as any).mockResolvedValue(activeProject);
+    });
+
+    it("should successfully edit an API key", async () => {
+        await editKey(mockKeyId);
+
+        expect(getProjectId).toHaveBeenCalled();
+
+        expect(fetchAuthenticated).toHaveBeenCalledWith(routes.api.console.projects.apiKeys(mockProjectId));
+
+        expect(checkbox).toHaveBeenCalledWith({
+            message: `Select scopes for ${mockKey.usageOrigin} key:`,
+            choices: getScopeChoices(mockKey.usageOrigin, "production", activeProject, mockKey.scopes),
+            validate: expect.any(Function),
+        });
+
+        expect(fetchAuthenticated).toHaveBeenCalledWith(
+            routes.api.console.projects.apiKeys(mockProjectId),
+            HttpMethods.PUT,
+            expect.objectContaining({
+                apiKeyId: mockKeyId,
+                scopes: ["wallets.read", "wallets.create"],
+            })
+        );
+    });
+    it("should not update API key scopes if they are the same", async () => {
+        (checkbox as any).mockResolvedValue(["wallets.read"]);
+        await editKey(mockKeyId);
+
+        expect(fetchAuthenticated).not.toHaveBeenCalledWith(
+            routes.api.console.projects.apiKeys(mockProjectId),
+            HttpMethods.PUT,
+            expect.objectContaining({
+                apiKeyId: mockKeyId,
+                scopes: ["wallets.read", "wallets.create"],
+            })
+        );
+    });
+
+    it("should exit if no project is selected", async () => {
+        (getProjectId as any).mockResolvedValue(null);
+
+        await expect(editKey(mockKeyId)).rejects.toThrow();
+        expect(console.error).toHaveBeenCalledWith(
+            "There is no project selected, please first run `crossmint project select`"
+        );
+        expect(process.exit).toHaveBeenCalledWith(1);
+    });
+
+    it("should handle API key not found error", async () => {
+        (fetchAuthenticated as any).mockResolvedValue([]);
+        await expect(editKey(mockKeyId)).rejects.toThrow();
+        expect(spinner.fail).toHaveBeenCalledWith("API key not found");
+        expect(process.exit).toHaveBeenCalledWith(1);
+    });
+
+    it("should handle update error", async () => {
+        (fetchAuthenticated as any).mockRejectedValueOnce(new Error("Update failed"));
+        await expect(editKey(mockKeyId)).rejects.toThrow();
+        expect(spinner.fail).toHaveBeenCalledWith(expect.stringContaining("❌ Failed to update API key"));
+        expect(process.exit).toHaveBeenCalledWith(1);
+    });
+
+    it("should update domains for client API key", async () => {
+        const clientKey: APIKeyDocument = {
+            ...mockKey,
+            usageOrigin: "client",
+            whitelistedOrigins: ["https://old-domain.com"],
+        };
+
+        vi.mocked(checkbox).mockResolvedValue(["wallets.read"]);
+        (fetchAuthenticated as any).mockResolvedValue([clientKey]);
+        (getWhitelistedOriginsAndAppIdentifiersPrompt as any).mockResolvedValue({
+            whitelistedOrigins: ["https://new-domain.com"],
+            whitelistedAppIdentifiers: [],
+        });
+
+        await editKey(mockKeyId);
+
+        expect(getWhitelistedOriginsAndAppIdentifiersPrompt).toHaveBeenCalledWith("web", ["https://old-domain.com"]);
+
+        expect(fetchAuthenticated).toHaveBeenCalledWith(
+            routes.api.console.projects.apiKeys(mockProjectId),
+            HttpMethods.PUT,
+            expect.objectContaining({
+                apiKeyId: mockKeyId,
+                whitelistedOrigins: ["https://new-domain.com"],
+                whitelistedAppIdentifiers: [],
+            })
+        );
+    });
+});

package/src/commands/keys/edit.ts

@@ -0,0 +1,98 @@
+import { HttpMethods, routes } from "@crossmint/common-consts";
+import { fetchAuthenticated } from "@/utils/fetch";
+import { getEnvironment, getProjectId } from "@/utils/store";
+import { APIKeyDocument, APIKeyScopes } from "@crossmint/products-console-types";
+import { getScopeChoices } from "@/utils/scopes";
+import { checkbox } from "@inquirer/prompts";
+import { createSpinner } from "@/utils/spinner";
+import { getProject } from "@/utils/getProject";
+import { getWhitelistedOriginsAndAppIdentifiersPrompt } from "@/utils/getWhitelistedOriginsAndAppIdentifiersPrompt";
+import { APIKeyPayload } from "@/types/keys";
+
+export default async function editKey(keyId: string) {
+    const environment = await getEnvironment();
+    if (!environment) {
+        console.error("There is no environment selected, please first run `crossmint login`");
+        process.exit(1);
+    }
+    const projectId = await getProjectId();
+    if (!projectId) {
+        console.error("There is no project selected, please first run `crossmint project select`");
+        process.exit(1);
+    }
+
+    const spinner = createSpinner("Fetching API key...");
+    try {
+        spinner.start();
+
+        const keys: APIKeyDocument[] = await fetchAuthenticated(routes.api.console.projects.apiKeys(projectId));
+        const key = keys.find((key) => key._id.toString() === keyId);
+        if (!key) {
+            spinner.fail("API key not found");
+            process.exit(1);
+        }
+        let whitelistedOrigins: string[] | undefined;
+        let whitelistedAppIdentifiers: string[] | undefined;
+        if (key.usageOrigin === "client") {
+            spinner.succeed("📌 Current API Key Whitelisted Origins:");
+            ({ whitelistedOrigins, whitelistedAppIdentifiers } = await getWhitelistedOriginsAndAppIdentifiersPrompt(
+                key.whitelistedOrigins?.length > 0 ? "web" : "mobile",
+                key.whitelistedOrigins?.length > 0 ? key.whitelistedOrigins : key.whitelistedAppIdentifiers
+            ));
+        }
+
+        spinner.succeed("📌 Current API Key Scopes:");
+        const activeProject = await getProject(projectId);
+        if (!activeProject) {
+            console.error("❌ Project not found, please run `crossmint project select`");
+            process.exit(1);
+        }
+        const choices = getScopeChoices(key.usageOrigin, environment, activeProject, key.scopes);
+
+        const selectedScopes = await checkbox({
+            message: `Select scopes for ${key.usageOrigin} key:`,
+            choices,
+            validate: (input) => {
+                if (input.length === 0) {
+                    return "At least one scope must be selected";
+                }
+                return true;
+            },
+        });
+        if (scopesChanged(key, selectedScopes) || originsChanged(key, whitelistedOrigins, whitelistedAppIdentifiers)) {
+            spinner.start("Updating API key scopes...");
+            const payload: APIKeyPayload = {
+                apiKeyId: keyId,
+                ...key,
+                scopes: selectedScopes,
+            };
+            if (key.usageOrigin === "client") {
+                payload.whitelistedOrigins = whitelistedOrigins;
+                payload.whitelistedAppIdentifiers = whitelistedAppIdentifiers;
+            }
+            await fetchAuthenticated(routes.api.console.projects.apiKeys(projectId), HttpMethods.PUT, payload);
+        }
+
+        spinner.succeed("✅ API key scopes updated successfully!");
+    } catch (error) {
+        spinner.fail(`❌ Failed to update API key: ${error instanceof Error ? error.message : "Unknown error"}`);
+        process.exit(1);
+    }
+}
+
+function scopesChanged(key: APIKeyDocument, selectedScopes: APIKeyScopes[]) {
+    return (
+        key.scopes.some((scope) => !selectedScopes.includes(scope)) ||
+        selectedScopes.some((scope) => !key.scopes.includes(scope))
+    );
+}
+
+function originsChanged(key: APIKeyDocument, selectedOrigins?: string[], selectedAppIdentifiers?: string[]) {
+    return (
+        key.usageOrigin === "client" &&
+        (key.whitelistedOrigins?.some((origin) => !selectedOrigins?.includes(origin)) ||
+            selectedOrigins?.some((origin) => !key.whitelistedOrigins?.includes(origin)) ||
+            key.whitelistedAppIdentifiers?.some((appIdentifier) => !selectedAppIdentifiers?.includes(appIdentifier)) ||
+            selectedAppIdentifiers?.some((appIdentifier) => !key.whitelistedAppIdentifiers?.includes(appIdentifier)))
+    );
+}

package/src/commands/keys/index.ts

@@ -0,0 +1,4 @@
+export { default as create } from "./create";
+export { default as list } from "./list";
+export { default as delete } from "./delete";
+export { default as edit } from "./edit";

package/src/commands/keys/list.test.ts

@@ -0,0 +1,123 @@
+import { describe, it, expect, vi, beforeEach, Mock } from "vitest";
+import listKeys from "./list";
+import { fetchAuthenticated } from "@/utils/fetch";
+import { getEnvironment, getProjectId } from "@/utils/store";
+import { Pager } from "@/utils/Pager";
+import { createSpinner } from "@/utils/spinner";
+
+// Mock dependencies
+vi.mock("@/utils/fetch");
+vi.mock("@/utils/store");
+vi.mock("@/utils/Pager");
+vi.mock("@/utils/spinner");
+
+describe("listKeys", () => {
+    const mockProjectId = "test-project-id";
+    const mockEnvironment = "development";
+    const mockKeys = [
+        {
+            _id: "key1",
+            clientSecret: "secret1",
+            usageOrigin: "server",
+            createdBy: "user1",
+            createdAt: "2024-01-01T00:00:00Z",
+            scopes: ["read", "write"],
+        },
+        {
+            _id: "key2",
+            clientSecret: "secret2",
+            usageOrigin: "client",
+            createdBy: "user2",
+            createdAt: "2024-01-02T00:00:00Z",
+            scopes: ["read"],
+            whitelistedOrigins: ["https://example.com"],
+            whitelistedAppIdentifiers: ["app1"],
+        },
+    ];
+    let addSpy: Mock;
+    let writeSpy: Mock;
+    let succeedSpy: Mock;
+    let failSpy: Mock;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        (getProjectId as any).mockResolvedValue(mockProjectId);
+        (getEnvironment as any).mockResolvedValue(mockEnvironment);
+        (fetchAuthenticated as any).mockResolvedValue(mockKeys);
+        addSpy = vi.fn();
+        writeSpy = vi.fn();
+        succeedSpy = vi.fn();
+        failSpy = vi.fn();
+        (Pager as any).mockImplementation(() => ({
+            add: addSpy,
+            write: writeSpy,
+        }));
+        (createSpinner as any).mockImplementation(() => ({
+            start: vi.fn(),
+            succeed: succeedSpy,
+            fail: failSpy,
+        }));
+    });
+
+    it("should exit if no project is selected", async () => {
+        vi.spyOn(console, "error");
+        (getProjectId as any).mockResolvedValue(null);
+
+        await expect(listKeys()).rejects.toThrow();
+        expect(process.exit).toHaveBeenCalledWith(1);
+    });
+
+    it("should exit if invalid key type is provided", async () => {
+        vi.spyOn(console, "error");
+        await expect(listKeys("invalid" as any)).rejects.toThrow();
+        expect(process.exit).toHaveBeenCalledWith(1);
+    });
+
+    it("should display message when no keys are found", async () => {
+        (fetchAuthenticated as any).mockResolvedValue([]);
+
+        await listKeys();
+        expect(succeedSpy).toHaveBeenCalledWith(
+            "🔍 No API keys found for this project. To create a new API key, run `crossmint keys create`"
+        );
+        expect(process.exit).toHaveBeenCalledWith(0);
+    });
+
+    it("should filter server keys when specified", async () => {
+        await listKeys("server");
+
+        expect(fetchAuthenticated).toHaveBeenCalled();
+        expect(addSpy).not.toHaveBeenCalledWith(expect.stringContaining("Client"));
+        expect(addSpy).toHaveBeenCalledWith(expect.stringContaining("Server"));
+    });
+
+    it("should filter client keys when specified", async () => {
+        await listKeys("client");
+
+        expect(fetchAuthenticated).toHaveBeenCalled();
+        expect(addSpy).toHaveBeenCalledWith(expect.stringContaining("Client"));
+        expect(addSpy).not.toHaveBeenCalledWith(expect.stringContaining("Server"));
+    });
+
+    it("should handle errors gracefully", async () => {
+        const mockError = new Error("Test error");
+        (fetchAuthenticated as any).mockRejectedValue(mockError);
+
+        await expect(listKeys()).rejects.toThrow();
+        expect(failSpy).toHaveBeenCalledWith(`❌ Failed to fetch keys: ${mockError.message}`);
+        expect(process.exit).toHaveBeenCalledWith(1);
+    });
+
+    it("should format server key secret correctly in production", async () => {
+        (getEnvironment as any).mockResolvedValue("production");
+        await listKeys("server");
+
+        expect(addSpy).toHaveBeenCalledWith(expect.stringContaining("******************"));
+    });
+
+    it("should show full key secret in development", async () => {
+        (getEnvironment as any).mockResolvedValue("development");
+        await listKeys("server");
+
+        expect(addSpy).toHaveBeenCalledWith(expect.stringContaining("secret1"));
+    });
+});

package/src/commands/keys/list.ts

@@ -0,0 +1,83 @@
+import { routes } from "@crossmint/common-consts";
+import { fetchAuthenticated } from "@/utils/fetch";
+import { getEnvironment, getProjectId } from "@/utils/store";
+import { APIKeyUsageOrigin, APIKeyUsageOriginArray, APIKeyDocument } from "@crossmint/products-console-types";
+import { capitalizeFirstLetter } from "@crossmint/common-string-utils";
+import { Pager } from "@/utils/Pager";
+import chalk from "chalk";
+import { createSpinner } from "@/utils/spinner";
+
+export default async function listKeys(keyType?: APIKeyUsageOrigin) {
+    const environment = await getEnvironment();
+    const projectId = await getProjectId();
+    if (!projectId) {
+        console.error("There is no project selected, please first run `crossmint project select`");
+        process.exit(1);
+    }
+    if (keyType && !APIKeyUsageOriginArray.includes(keyType)) {
+        console.error("Invalid key type. Please use 'server' or 'client'.");
+        process.exit(1);
+    }
+
+    const spinner = createSpinner("Fetching API keys...");
+    try {
+        spinner.start();
+
+        const keys: APIKeyDocument[] = await fetchAuthenticated(routes.api.console.projects.apiKeys(projectId));
+
+        const filteredKeys = keyType ? keys.filter((key) => key.usageOrigin === keyType) : keys;
+
+        if (filteredKeys.length === 0) {
+            spinner.succeed(
+                "🔍 No API keys found for this project. To create a new API key, run `crossmint keys create`"
+            );
+            return process.exit(0);
+        }
+
+        spinner.succeed("📌 List of API Keys:");
+
+        const pager = new Pager();
+
+        const separator = chalk.bold.magenta("=========");
+
+        filteredKeys.forEach((key, index) => {
+            pager.add(`\n${separator}\n\n`);
+            pager.add(`${chalk.bold(`${index + 1}. Key ID:`)} ${key._id}\n`);
+
+            const keySecret =
+                key.usageOrigin === "server" && environment === "production"
+                    ? `******************${key.clientSecret.slice(-4)}`
+                    : key.clientSecret;
+
+            pager.add(`   ${chalk.bold(`Key Secret:`)} ${keySecret}\n\n`);
+
+            const details: Array<[string, string | undefined]> = [
+                ["Type", capitalizeFirstLetter(key.usageOrigin)],
+                ["Created By", key.createdBy],
+                ["Created", key.createdAt ? new Date(key.createdAt).toLocaleString() : undefined],
+                ["Scopes", key.scopes.join(", ")],
+            ];
+
+            if (key.usageOrigin === "client") {
+                if (key.whitelistedOrigins.length > 0) {
+                    details.push(["Whitelisted Origins", key.whitelistedOrigins.join(", ")]);
+                }
+                if (key.whitelistedAppIdentifiers && key.whitelistedAppIdentifiers.length > 0) {
+                    details.push(["Whitelisted App IDs", key.whitelistedAppIdentifiers.join(", ")]);
+                }
+            }
+
+            details.forEach(([label, value]) => {
+                if (value !== undefined) {
+                    pager.add(`${chalk.cyan(label.padEnd(20))} ${value}\n`);
+                }
+            });
+        });
+        pager.add(`\n${separator}`);
+
+        pager.write();
+    } catch (error) {
+        spinner.fail(`❌ Failed to fetch keys: ${error instanceof Error ? error.message : "Unknown error"}`);
+        process.exit(1);
+    }
+}

package/src/commands/login.test.ts

@@ -0,0 +1,87 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { select } from "@inquirer/prompts";
+import { getCrossmintUrl } from "@/utils/urls";
+import { setEnvironment } from "@/utils/store";
+import login from "./login";
+import selectProject from "./projects/select";
+import open from "open";
+import { generateCodeChallenge } from "@/utils/oauth/codeChallenge";
+import server from "@/utils/oauth/server";
+import { ChildProcess } from "child_process";
+
+vi.mock("@inquirer/prompts");
+vi.mock("@/utils/urls");
+vi.mock("@/utils/store");
+vi.mock("@/utils/oauth/codeChallenge");
+vi.mock("@/utils/oauth/server");
+vi.mock("open");
+vi.mock("./projects/select");
+
+describe("login", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+
+    afterEach(() => {
+        vi.resetAllMocks();
+    });
+
+    it("should successfully log in a user using OAuth", async () => {
+        const mockEnvironment = "production";
+        const mockUrl = "https://api.crossmint.com";
+        const mockCodeChallenge = "mock-code-challenge";
+        const mockChildProcess = { pid: 123 } as ChildProcess;
+
+        vi.mocked(select).mockResolvedValueOnce(mockEnvironment);
+        vi.mocked(getCrossmintUrl).mockReturnValue(mockUrl);
+        vi.mocked(generateCodeChallenge).mockResolvedValue(mockCodeChallenge);
+        vi.mocked(server).mockResolvedValue(undefined);
+        vi.mocked(open).mockResolvedValue(mockChildProcess);
+
+        const consoleLogSpy = vi.spyOn(console, "log");
+        await login();
+
+        expect(getCrossmintUrl).toHaveBeenCalledWith(mockEnvironment);
+        expect(setEnvironment).toHaveBeenCalledWith(mockEnvironment);
+        expect(generateCodeChallenge).toHaveBeenCalled();
+        expect(server).toHaveBeenCalledWith(mockEnvironment);
+        expect(open).toHaveBeenCalledWith(expect.stringContaining(mockUrl));
+        expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining("Opening browser for authentication"));
+        expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining("Login successful"));
+        expect(selectProject).toHaveBeenCalled();
+    });
+
+    it("should exit if no URL is found for the environment", async () => {
+        vi.mocked(select).mockResolvedValueOnce("not-valid");
+        vi.mocked(getCrossmintUrl).mockReturnValue("");
+
+        const consoleErrorSpy = vi.spyOn(console, "error");
+        const processExitSpy = vi.spyOn(process, "exit").mockImplementation(() => undefined as never);
+
+        await login();
+
+        expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("No URL found"));
+        expect(processExitSpy).toHaveBeenCalledWith(1);
+    });
+
+    it("should handle server error", async () => {
+        const mockEnvironment = "production";
+        const mockUrl = "https://api.crossmint.com";
+        const mockCodeChallenge = "mock-code-challenge";
+        const mockChildProcess = { pid: 123 } as ChildProcess;
+
+        vi.mocked(select).mockResolvedValueOnce(mockEnvironment);
+        vi.mocked(getCrossmintUrl).mockReturnValue(mockUrl);
+        vi.mocked(generateCodeChallenge).mockResolvedValue(mockCodeChallenge);
+        vi.mocked(server).mockRejectedValue(new Error("Server error"));
+        vi.mocked(open).mockResolvedValue(mockChildProcess);
+
+        const consoleErrorSpy = vi.spyOn(console, "error");
+        const processExitSpy = vi.spyOn(process, "exit").mockImplementation(() => undefined as never);
+
+        await login();
+
+        expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("Login failed"));
+        expect(processExitSpy).toHaveBeenCalledWith(1);
+    });
+});