@crossmint/cli 1.1.2

package/src/commands/login.ts

@@ -0,0 +1,59 @@
+import { Environment, getCrossmintUrl } from "@/utils/urls";
+import { setEnvironment } from "@/utils/store";
+import { select } from "@inquirer/prompts";
+import selectProject from "./projects/select";
+import open from "open";
+import { generateCodeChallenge } from "@/utils/oauth/codeChallenge";
+import server from "@/utils/oauth/server";
+import { getStytchConfig } from "@/utils/oauth/getStytchConfig";
+import { routes } from "@crossmint/common-consts";
+
+const isLocal = process.env.NODE_ENV === "development";
+
+export default async function login() {
+    try {
+        console.log("🔐 Crossmint CLI - Login");
+
+        const environment = await select<Environment>({
+            message: "Select environment:",
+            choices: [
+                { name: "Production", value: "production" },
+                { name: "Staging", value: "staging" },
+                ...(isLocal ? [{ name: "Local", value: "local" as Environment }] : []),
+            ],
+        });
+
+        const baseUrl = getCrossmintUrl(environment);
+        if (!baseUrl) {
+            console.error(`Error: No URL found for ${environment} environment`);
+            process.exit(1);
+        }
+
+        await setEnvironment(environment);
+
+        const serverPromise = server(environment);
+
+        const { clientId } = await getStytchConfig();
+
+        const codeChallenge = await generateCodeChallenge();
+        const options = {
+            code_challenge: codeChallenge,
+            code_challenge_method: "S256",
+            scope: "full_access",
+            response_type: "code",
+            grant_type: "authorization_code",
+            redirect_uri: "http://127.0.0.1:3456/callback",
+            client_id: clientId,
+        };
+        const authUrl = `${baseUrl}${routes.console.authorizeDevice.index(options)}`;
+        console.log("Opening browser for authentication...");
+        open(authUrl);
+        await serverPromise;
+
+        console.log(`✅ Login successful! You are now authenticated in the ${environment} environment.`);
+        await selectProject();
+    } catch {
+        console.error("❌ Login failed, please try again.");
+        process.exit(1);
+    }
+}

package/src/commands/logout.ts

@@ -0,0 +1,9 @@
+import { deleteEnvironment, deleteProjectId, deleteSessionToken } from "@/utils/store";
+
+export default async function logout(): Promise<void> {
+    await deleteSessionToken();
+    await deleteEnvironment();
+    await deleteProjectId();
+    console.log("Logged out");
+    process.exit(0);
+}

package/src/commands/projects/create.test.ts

@@ -0,0 +1,82 @@
+import { vi, describe, it, expect, beforeEach } from "vitest";
+import createProject from "./create";
+import { fetchAuthenticated } from "@/utils/fetch";
+import { confirm, input } from "@inquirer/prompts";
+import { HttpMethods } from "@crossmint/common-consts";
+import { routes } from "@crossmint/common-consts";
+import { setProjectId } from "@/utils/store";
+import { createSpinner } from "@/utils/spinner";
+
+vi.mock("@/utils/fetch");
+vi.mock("@inquirer/prompts");
+vi.mock("@/utils/store");
+vi.mock("@/utils/spinner");
+
+describe("createProject", () => {
+    let spinner: any;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        spinner = {
+            start: vi.fn(),
+            succeed: vi.fn(),
+            fail: vi.fn(),
+        };
+        vi.mocked(createSpinner).mockReturnValue(spinner);
+    });
+
+    const mockResponse = JSON.stringify({ _id: "123", kableClientId: "456" });
+    it("should create a project with provided name", async () => {
+        const projectName = "Test Project";
+        vi.mocked(fetchAuthenticated).mockResolvedValue(mockResponse);
+        vi.mocked(confirm).mockResolvedValue(true);
+
+        await createProject({ name: projectName });
+
+        expect(fetchAuthenticated).toHaveBeenCalledWith(routes.api.console.projects.index, HttpMethods.POST, {
+            name: projectName,
+            walletType: "smart_wallet",
+            storageProvider: "ipfs",
+            projectThumbnail: "",
+        });
+        expect(spinner.start).toHaveBeenCalledWith(expect.stringContaining("Creating project"));
+        expect(spinner.succeed).toHaveBeenCalledWith(expect.stringContaining("✅ Project created successfully!"));
+        expect(setProjectId).toHaveBeenCalledWith("123");
+        expect(input).not.toHaveBeenCalled();
+    });
+
+    it("should prompt for project name if not provided", async () => {
+        const projectName = "Test Project";
+        vi.mocked(fetchAuthenticated).mockResolvedValue(mockResponse);
+        vi.mocked(input).mockResolvedValue(projectName);
+        vi.mocked(confirm).mockResolvedValue(true);
+
+        await createProject();
+
+        expect(input).toHaveBeenCalledWith({
+            message: "Enter project name:",
+            validate: expect.any(Function),
+        });
+        expect(fetchAuthenticated).toHaveBeenCalledWith(routes.api.console.projects.index, HttpMethods.POST, {
+            name: projectName,
+            walletType: "smart_wallet",
+            storageProvider: "ipfs",
+            projectThumbnail: "",
+        });
+        expect(spinner.start).toHaveBeenCalledWith(expect.stringContaining("Creating project"));
+        expect(spinner.succeed).toHaveBeenCalledWith(expect.stringContaining("✅ Project created successfully!"));
+        expect(setProjectId).toHaveBeenCalledWith("123");
+    });
+    it("should not select project if user does not confirm", async () => {
+        vi.mocked(confirm).mockResolvedValue(false);
+        await createProject();
+        expect(setProjectId).not.toHaveBeenCalled();
+    });
+
+    it("should handle API errors", async () => {
+        const error = new Error("API Error");
+        vi.mocked(fetchAuthenticated).mockRejectedValue(error);
+
+        await expect(createProject({ name: "Test Project" })).rejects.toThrow();
+        expect(spinner.fail).toHaveBeenCalledWith(expect.stringContaining("Failed to create project"));
+    });
+});

package/src/commands/projects/create.ts

@@ -0,0 +1,45 @@
+import { confirm, input } from "@inquirer/prompts";
+import { fetchAuthenticated } from "@/utils/fetch";
+import { HttpMethods } from "@crossmint/common-consts";
+import { routes } from "@crossmint/common-consts";
+import { setProjectId } from "@/utils/store";
+import { createSpinner } from "@/utils/spinner";
+interface CreateProjectOptions {
+    name?: string;
+}
+
+export default async function createProject(options: CreateProjectOptions = {}) {
+    const spinner = createSpinner();
+    try {
+        let projectName = options.name;
+
+        if (!projectName) {
+            projectName = await input({
+                message: "Enter project name:",
+                validate: (input) => input.length > 0 || "Project name is required",
+            });
+        }
+
+        spinner.start(`🚀 Creating project "${projectName}" with Smart Wallets...`);
+        const response = await fetchAuthenticated(routes.api.console.projects.index, HttpMethods.POST, {
+            name: projectName,
+            walletType: "smart_wallet",
+            storageProvider: "ipfs",
+            projectThumbnail: "",
+        });
+        const project = JSON.parse(response);
+        spinner.succeed(`✅ Project created successfully!\n\n`);
+        console.log(`📌 Project Details:\nName: ${projectName}\nID: ${project.kableClientId}\n`);
+        const selectProject = await confirm({
+            message: "Do you want to select this project?",
+        });
+        if (selectProject) {
+            await setProjectId(project._id);
+            console.log(`✅Project '${projectName}' selected`);
+        }
+        process.exit(0);
+    } catch (error) {
+        spinner.fail(`❌ Failed to create project: ${error instanceof Error ? error.message : "Unknown error"}`);
+        process.exit(1);
+    }
+}

package/src/commands/projects/details.test.ts

@@ -0,0 +1,64 @@
+import { vi, describe, it, expect, beforeEach } from "vitest";
+import showProjectDetails from "./details";
+import { fetchAuthenticated } from "@/utils/fetch";
+import { getProjectId } from "@/utils/store";
+
+// Mock dependencies
+vi.mock("@/utils/fetch", () => ({
+    fetchAuthenticated: vi.fn(),
+}));
+
+vi.mock("@/utils/store", () => ({
+    getProjectId: vi.fn(),
+}));
+
+describe("showProjectDetails", () => {
+    const mockProject = {
+        id: "test-project-id",
+        name: "Test Project",
+        kableClientId: "test-client-id",
+        addons: {
+            nonCustodialWallets: true,
+        },
+    };
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.mocked(getProjectId).mockResolvedValue("test-project-id");
+        vi.mocked(fetchAuthenticated).mockResolvedValue([mockProject]);
+    });
+
+    it("should show details of the currently selected project", async () => {
+        const consoleSpy = vi.spyOn(console, "log");
+        await showProjectDetails();
+
+        expect(getProjectId).toHaveBeenCalled();
+        expect(fetchAuthenticated).toHaveBeenCalled();
+        expect(consoleSpy).toHaveBeenCalledWith("\n📌 Project Details:");
+        expect(consoleSpy).toHaveBeenCalledWith("Name: Test Project");
+        expect(consoleSpy).toHaveBeenCalledWith("ID: test-client-id");
+        expect(consoleSpy).toHaveBeenCalledWith("Wallet Type: Smart");
+    });
+
+    it("should handle case when no project is selected", async () => {
+        vi.mocked(getProjectId).mockResolvedValue(null);
+
+        await expect(showProjectDetails()).rejects.toThrow();
+        expect(process.exit).toHaveBeenCalledWith(1);
+    });
+
+    it("should handle case when project is not found", async () => {
+        vi.mocked(fetchAuthenticated).mockResolvedValue([]);
+
+        await expect(showProjectDetails()).rejects.toThrow();
+        expect(process.exit).toHaveBeenCalledWith(1);
+    });
+
+    it("should handle API errors", async () => {
+        const error = new Error("API Error");
+        vi.mocked(fetchAuthenticated).mockRejectedValue(error);
+
+        await expect(showProjectDetails()).rejects.toThrow();
+        expect(process.exit).toHaveBeenCalledWith(1);
+    });
+});

package/src/commands/projects/details.ts

@@ -0,0 +1,36 @@
+import { getProjectId } from "@/utils/store";
+import { createSpinner } from "@/utils/spinner";
+import { getProject } from "@/utils/getProject";
+
+export default async function showProjectDetails() {
+    const projectId = await getProjectId();
+    if (!projectId) {
+        console.error("No project selected. Please select a project first using `crossmint project select`");
+        process.exit(1);
+    }
+
+    const spinner = createSpinner("Fetching project details...").start();
+
+    try {
+        const project = await getProject(projectId);
+
+        if (!project) {
+            spinner.fail("Project not found");
+            process.exit(1);
+        }
+
+        spinner.succeed("Fetched project details");
+
+        console.log("\n📌 Project Details:");
+
+        console.log(`Name: ${project.name}`);
+        console.log(`ID: ${project.kableClientId}`);
+        console.log(`Wallet Type: ${project.addons.nonCustodialWallets ? "Smart" : "Custodial"}`);
+
+        process.exit(0);
+    } catch (error) {
+        spinner.fail("Failed to fetch project details");
+        console.error("Error:", error instanceof Error ? error.message : "Unknown error");
+        process.exit(1);
+    }
+}

package/src/commands/projects/index.ts

@@ -0,0 +1,3 @@
+export { default as select } from "./select";
+export { default as create } from "./create";
+export { default as details } from "./details";

package/src/commands/projects/select.test.ts

@@ -0,0 +1,86 @@
+import { vi, describe, it, expect, beforeEach } from "vitest";
+import selectProject from "./select";
+import { fetchAuthenticated } from "@/utils/fetch";
+import { setProjectId } from "@/utils/store";
+import { select } from "@inquirer/prompts";
+import { createSpinner } from "@/utils/spinner";
+
+vi.mock("@/utils/fetch", () => ({
+    fetchAuthenticated: vi.fn(),
+}));
+vi.mock("@/utils/store");
+vi.mock("@inquirer/prompts");
+vi.mock("@/utils/spinner");
+
+describe("selectProject", () => {
+    const mockProjects = [
+        { id: "1", name: "Project 1", description: "First project" },
+        { id: "2", name: "Project 2", description: "Second project" },
+    ];
+
+    let spinner: any;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        spinner = {
+            start: vi.fn(() => spinner),
+            succeed: vi.fn(),
+            fail: vi.fn(),
+        };
+        vi.mocked(createSpinner).mockReturnValue(spinner);
+    });
+
+    it("should handle no projects", async () => {
+        vi.mocked(fetchAuthenticated).mockResolvedValue([]);
+        const consoleSpy = vi.spyOn(console, "log");
+
+        await selectProject();
+
+        expect(spinner.fail).toHaveBeenCalledWith(
+            "No projects found. Create a new project using `crossmint project create`"
+        );
+        expect(setProjectId).not.toHaveBeenCalled();
+    });
+
+    it("should auto-select single project", async () => {
+        const singleProject = [mockProjects[0]];
+        vi.mocked(fetchAuthenticated).mockResolvedValue(singleProject);
+        const consoleSpy = vi.spyOn(console, "log");
+
+        await selectProject();
+
+        expect(consoleSpy).toHaveBeenCalledWith(`You only have one project: ${singleProject[0].name}`);
+        expect(consoleSpy).toHaveBeenCalledWith("To create another project, run `crossmint project create`");
+        expect(setProjectId).toHaveBeenCalledWith(singleProject[0].id);
+        expect(select).not.toHaveBeenCalled();
+    });
+
+    it("should allow project selection from multiple projects", async () => {
+        vi.mocked(fetchAuthenticated).mockResolvedValue(mockProjects);
+        vi.mocked(select).mockResolvedValue(mockProjects[1]);
+        const consoleSpy = vi.spyOn(console, "log");
+
+        await selectProject();
+
+        expect(select).toHaveBeenCalledWith({
+            message: "Select a project:",
+            choices: mockProjects.map((project) => ({
+                name: project.name,
+                value: project,
+                description: project.description,
+            })),
+        });
+        expect(setProjectId).toHaveBeenCalledWith(mockProjects[1].id);
+        expect(consoleSpy).toHaveBeenCalledWith(`✅ Project ${mockProjects[1].name} selected`);
+    });
+
+    it("should handle API errors", async () => {
+        const error = new Error("API Error");
+        vi.mocked(fetchAuthenticated).mockRejectedValue(error);
+
+        await expect(selectProject()).rejects.toThrow();
+        expect(spinner.fail).toHaveBeenCalledWith(expect.stringContaining("Failed to fetch projects"));
+        expect(setProjectId).not.toHaveBeenCalled();
+        expect(select).not.toHaveBeenCalled();
+    });
+});

package/src/commands/projects/select.ts

@@ -0,0 +1,50 @@
+import { fetchAuthenticated } from "@/utils/fetch";
+import { routes } from "@crossmint/common-consts";
+import { setProjectId } from "@/utils/store";
+import { select } from "@inquirer/prompts";
+import { createSpinner } from "@/utils/spinner";
+
+interface Project {
+    id: string;
+    name: string;
+    description?: string;
+}
+
+export default async function selectProject() {
+    const spinner = createSpinner("Fetching projects...").start();
+    try {
+        const projects = (await fetchAuthenticated(routes.api.projects)) as Project[];
+
+        if (!projects || projects.length === 0) {
+            spinner.fail("No projects found. Create a new project using `crossmint project create`");
+            return process.exit(0);
+        }
+
+        spinner.succeed("Fetched projects");
+
+        if (projects.length === 1) {
+            const project = projects[0];
+            console.log(`You only have one project: ${project.name}`);
+            console.log("To create another project, run `crossmint project create`");
+            await setProjectId(project.id);
+            console.log(`✅ Project ${project.name} selected`);
+            return process.exit(0);
+        }
+
+        const selectedProject = await select<Project>({
+            message: "Select a project:",
+            choices: projects.map((project) => ({
+                name: project.name,
+                value: project,
+                description: project.description,
+            })),
+        });
+
+        await setProjectId(selectedProject.id);
+        console.log(`✅ Project ${selectedProject.name} selected`);
+        process.exit(0);
+    } catch (error) {
+        spinner.fail("Failed to fetch projects");
+        process.exit(1);
+    }
+}

package/src/commands/whoami.ts

@@ -0,0 +1,19 @@
+import { fetchAuthenticated } from "@/utils/fetch";
+import { getEnvironment } from "@/utils/store";
+import { routes } from "@crossmint/common-consts";
+import { getProjectId } from "@/utils/store";
+import { getProject } from "@/utils/getProject";
+import { capitalizeFirstLetter } from "@crossmint/common-string-utils";
+
+export default async function whoami() {
+    const environment = await getEnvironment();
+    const projectId = await getProjectId();
+
+    const project = await getProject(projectId || "");
+
+    const response = await fetchAuthenticated(routes.authentication.getSession);
+    console.log(
+        `You are logged in to 🍀Crossmint as: ${response.user.email} - Environment: ${capitalizeFirstLetter(environment!)} - ${project ? `Project: ${project.name}` : "No project selected"}`
+    );
+    process.exit(0);
+}

package/src/types/keys.ts

@@ -0,0 +1,13 @@
+import { APIKeyScopes } from "@crossmint/products-console-types";
+
+import { APIKeyUsageOrigin } from "@crossmint/products-console-types";
+
+export type ClientPlatform = "web" | "mobile";
+
+export type APIKeyPayload = {
+    apiKeyId?: string;
+    usageOrigin: APIKeyUsageOrigin;
+    scopes: APIKeyScopes[];
+    whitelistedOrigins?: string[];
+    whitelistedAppIdentifiers?: string[];
+};

package/src/utils/Pager.test.ts

@@ -0,0 +1,70 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { Pager } from "./Pager";
+
+// Mock child_process.spawn
+vi.mock("child_process", () => ({
+    spawn: vi.fn(() => ({
+        stdin: {
+            write: vi.fn(),
+            end: vi.fn(),
+            kill: vi.fn(),
+        },
+        on: vi.fn((event, callback) => {
+            if (event === "exit") {
+                callback(0);
+            }
+        }),
+    })),
+}));
+
+describe("Pager", () => {
+    let pager: Pager;
+    let consoleSpy: ReturnType<typeof vi.spyOn>;
+    let mockStdin: any;
+    beforeEach(() => {
+        pager = new Pager();
+        consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+        vi.clearAllMocks();
+        mockStdin = {
+            write: vi.fn(),
+            end: vi.fn(),
+        };
+        (pager as any).pager.stdin = mockStdin;
+        (pager as any).pager.kill = vi.fn();
+    });
+
+    it("should accumulate output when adding content", () => {
+        pager.add("test1");
+        pager.add("test2");
+        pager.write();
+
+        expect(pager["output"]).toBe("test1test2");
+    });
+
+    it("should write accumulated output to stdin when terminal height is exceeded", () => {
+        process.stdout.rows = 1;
+        const textContent = "test content\nwith multiple lines";
+
+        pager.add(textContent);
+        pager.write();
+
+        expect(mockStdin.write).toHaveBeenCalledWith(textContent);
+        expect(mockStdin.end).toHaveBeenCalled();
+    });
+    it("should not use pager when terminal height is not exceeded", () => {
+        process.stdout.rows = 10;
+
+        pager.add("test content");
+        pager.write();
+
+        expect(mockStdin.write).not.toHaveBeenCalled();
+        expect(mockStdin.end).not.toHaveBeenCalled();
+        expect((pager as any).pager.kill).toHaveBeenCalled();
+    });
+
+    it("should log output and exit when pager closes", () => {
+        pager = new Pager();
+        expect(consoleSpy).toHaveBeenCalledWith("");
+        expect(process.exit).toHaveBeenCalledWith(0);
+    });
+});

package/src/utils/Pager.ts

@@ -0,0 +1,34 @@
+import { spawn } from "child_process";
+
+export class Pager {
+    private output = "";
+    private pager: ReturnType<typeof spawn>;
+
+    constructor() {
+        this.pager = spawn("less", ["-R"], { stdio: ["pipe", "inherit", "inherit"] });
+        this.pager.on("exit", (code) => {
+            console.log(this.output);
+            process.exit(code ?? 0);
+        });
+    }
+
+    add(content: string) {
+        this.output += content;
+    }
+
+    private shouldUsePager(): boolean {
+        const terminalHeight = process.stdout.rows;
+        const contentLines = this.output.split("\n").length;
+
+        return contentLines > terminalHeight;
+    }
+
+    write() {
+        if (this.shouldUsePager()) {
+            this.pager.stdin?.write(this.output);
+            this.pager.stdin?.end();
+        } else {
+            this.pager.kill();
+        }
+    }
+}

package/src/utils/fetch.ts

@@ -0,0 +1,63 @@
+import { HttpMethods } from "@crossmint/common-consts";
+import { getSessionToken, getEnvironment } from "./store";
+import { getCrossmintUrl } from "./urls";
+
+export async function fetchAuthenticated(path: string, method: HttpMethods = HttpMethods.GET, body?: any) {
+    const sessionToken = await getSessionToken();
+    const environment = await getEnvironment();
+    if (!sessionToken) {
+        console.error("❌ Session not found, please run crossmint login");
+        process.exit(1);
+    }
+
+    if (!environment) {
+        console.error("❌ Environment not found, please run crossmint login");
+        process.exit(1);
+    }
+
+    const url = `${getCrossmintUrl(environment)}${path}`;
+
+    return fetchJSON(url, method, body, {
+        Cookie: `sessionToken=${sessionToken}`,
+    });
+}
+
+export async function fetchUnauthenticated(path: string, method: HttpMethods = HttpMethods.GET, body?: any) {
+    const environment = await getEnvironment();
+    if (!environment) {
+        console.error("❌ Environment not found");
+        process.exit(1);
+    }
+
+    const url = `${getCrossmintUrl(environment)}${path}`;
+
+    return fetchJSON(url, method, body);
+}
+
+export async function fetchJSON(
+    url: string,
+    method: HttpMethods = HttpMethods.GET,
+    body?: any,
+    headers?: Record<string, string>
+) {
+    const options: RequestInit = {
+        method,
+        headers: {
+            "Content-Type": "application/json",
+            ...headers,
+        },
+    };
+
+    if (body) {
+        options.body = JSON.stringify(body);
+    }
+
+    const response = await fetch(url, options);
+
+    if (response.status >= 400) {
+        const error = await response.json();
+        throw new Error(`${error.message}`);
+    }
+
+    return await response.json();
+}

package/src/utils/getProject.ts

@@ -0,0 +1,10 @@
+import { DeveloperProject } from "@crossmint/common-types";
+import { fetchAuthenticated } from "./fetch";
+import { routes } from "@crossmint/common-consts";
+import { PrimitiveProperties } from "@crossmint/data-dbs-types";
+
+export async function getProject(projectId: string) {
+    const projects: PrimitiveProperties<DeveloperProject>[] = await fetchAuthenticated(routes.api.projects);
+    const project = projects.find((p) => p.id === projectId);
+    return project;
+}