@crossmint/cli 1.1.2

package/src/utils/getWhitelistedOriginsAndAppIdentifiersPrompt.ts

@@ -0,0 +1,52 @@
+import { input } from "@inquirer/prompts";
+import { ClientPlatform } from "@/types/keys";
+
+function isValidUrl(url: string) {
+    try {
+        new URL(url);
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+
+export async function getWhitelistedOriginsAndAppIdentifiersPrompt(clientPlatform: ClientPlatform, values?: string[]) {
+    const whitelistedOrigins: string[] = [];
+    const whitelistedAppIdentifiers: string[] = [];
+
+    const instructions = values ? "\nPress [tab] to edit or [enter] to confirm current value" : "";
+
+    if (clientPlatform === "web") {
+        const domains = await input({
+            default: values?.join(","),
+            message: `Enter whitelisted domain or localhost (e.g., https://www.yourdomain.com) (separate multiple domains with a comma):${instructions}`,
+            validate: (input) => {
+                const domains = input.split(",");
+                for (const domain of domains) {
+                    if (!isValidUrl(domain)) {
+                        return `Invalid domain: ${domain}. Please enter a valid URL (e.g., https://www.yourdomain.com)`;
+                    }
+                }
+                return true;
+            },
+        });
+        whitelistedOrigins.push(...domains.split(",").map((domain) => domain.trim()));
+    } else if (clientPlatform === "mobile") {
+        const appIdentifiers = await input({
+            default: values?.join(","),
+            message: `Enter iOS bundle ID  or Android package name (e.g., com.company.appname) (separate multiple domains with a comma):${instructions}`,
+            validate: (input) => {
+                const appIdentifiers = input.split(",");
+                for (const appIdentifier of appIdentifiers) {
+                    if (appIdentifier.trim().length === 0) {
+                        return "App identifier cannot be empty";
+                    }
+                }
+                return true;
+            },
+        });
+        whitelistedAppIdentifiers.push(...appIdentifiers.split(",").map((identifier) => identifier.trim()));
+    }
+
+    return { whitelistedOrigins, whitelistedAppIdentifiers };
+}

package/src/utils/keytar.ts

@@ -0,0 +1,15 @@
+import keytar from "keytar";
+
+const SERVICE_NAME = process.env.NODE_ENV === "development" ? "crossmint-cli-dev" : "crossmint-cli";
+
+export async function set(property: string, value: string) {
+    return keytar.setPassword(SERVICE_NAME, property, value);
+}
+
+export async function get(property: string) {
+    return keytar.getPassword(SERVICE_NAME, property);
+}
+
+export async function del(property: string) {
+    return keytar.deletePassword(SERVICE_NAME, property);
+}

package/src/utils/oauth/codeChallenge.ts

@@ -0,0 +1,18 @@
+import crypto from "crypto";
+import * as storage from "../keytar";
+
+export async function generateCodeChallenge(): Promise<string> {
+    const buffer = crypto.randomBytes(32);
+    const codeVerifier = buffer.toString("base64url");
+
+    const hash = crypto.createHash("sha256").update(codeVerifier).digest();
+    const codeChallenge = hash.toString("base64url");
+
+    await storage.set("pkceCodeVerifier", codeVerifier);
+
+    return codeChallenge;
+}
+
+export async function getCodeVerifier(): Promise<string | null> {
+    return await storage.get("pkceCodeVerifier");
+}

package/src/utils/oauth/getStytchConfig.ts

@@ -0,0 +1,28 @@
+import { getEnvironment } from "../store";
+
+export async function getStytchConfig() {
+    const environment = await getEnvironment();
+    if (!environment) {
+        console.error("❌ Environment not found");
+        process.exit(1);
+    }
+    if (environment === "local") {
+        return {
+            uri: "test.stytch.com",
+            projectId: "project-test-8eb55d3d-949f-4e0f-aea6-c9ba740f7813",
+            clientId: "connected-app-test-4d27d6d8-3491-45c8-9bb0-b05f89cb7a1a",
+        };
+    }
+    if (environment === "staging") {
+        return {
+            uri: "api.stytch.com",
+            projectId: "project-live-b7c564af-0c0d-4662-bfc0-72bed1049cfe",
+            clientId: "connected-app-live-47cd5bf1-c155-42c1-9f36-5d35853b34a7",
+        };
+    }
+    return {
+        uri: "api.stytch.com",
+        projectId: "project-live-7a1cb98d-b8b7-4471-aaf6-f8af67a0df94",
+        clientId: "connected-app-live-a72edd7e-6ff3-4002-a13a-e7ca66354bd1",
+    };
+}

package/src/utils/oauth/server.ts

@@ -0,0 +1,66 @@
+import http from "http";
+import { Environment, getCrossmintUrl } from "../urls";
+import { getCodeVerifier } from "./codeChallenge";
+import { setSessionToken } from "../store";
+import { fetchJSON, fetchUnauthenticated } from "../fetch";
+import { HttpMethods } from "@crossmint/common-consts";
+import { routes } from "@crossmint/common-consts";
+import { getStytchConfig } from "./getStytchConfig";
+
+export default async function server(environment: Environment) {
+    return new Promise((resolve, reject) => {
+        const server = http.createServer(async (req, res) => {
+            try {
+                const url = new URL(req.url || "", `http://${req.headers.host}`);
+                const code = url.searchParams.get("code");
+
+                if (!code) {
+                    res.writeHead(400, { "Content-Type": "text/plain" });
+                    res.end("No code provided");
+                    return;
+                }
+
+                const stytchConfig = await getStytchConfig();
+
+                // Exchange the code with Stytch's token endpoint
+                const tokenResponse = await fetchJSON(
+                    `https://${stytchConfig.uri}/v1/public/${stytchConfig.projectId}/oauth2/token`,
+                    HttpMethods.POST,
+                    {
+                        grant_type: "authorization_code",
+                        code,
+                        client_id: stytchConfig.clientId,
+                        redirect_uri: "http://127.0.0.1:3456/callback",
+                        code_verifier: await getCodeVerifier(),
+                    }
+                );
+
+                const sessionResponse = await fetchUnauthenticated(
+                    routes.authentication.exchangeAccessToken,
+                    HttpMethods.POST,
+                    {
+                        accessToken: tokenResponse.access_token,
+                    }
+                );
+
+                await setSessionToken(sessionResponse.sessionToken);
+
+                res.writeHead(302, {
+                    Location: `${getCrossmintUrl(environment)}${routes.console.authorizeDevice.success}`,
+                });
+                res.end();
+
+                server.close();
+                resolve(tokenResponse);
+            } catch (error) {
+                res.writeHead(500, { "Content-Type": "text/plain" });
+                res.end("Error during authentication");
+                server.close();
+                reject(error);
+            }
+        });
+
+        const port = 3456;
+        server.listen(port);
+    });
+}

package/src/utils/scopes.ts

@@ -0,0 +1,66 @@
+import { Separator } from "@inquirer/prompts";
+import {
+    APIKeyScopeDetails,
+    APIKeyScopes,
+    APIKeyUsageOrigin,
+    CLIENT_API_KEY_PUBLIC_SCOPES,
+    SERVER_API_KEY_PUBLIC_SCOPES,
+    APIKeyCategories,
+    APIKeyCategoryNames,
+} from "@crossmint/products-console-types";
+import { Environment } from "./urls";
+import { DeveloperProject } from "@crossmint/common-types";
+import { PrimitiveProperties } from "@crossmint/data-dbs-types";
+
+type ScopeChoice = {
+    name: string;
+    value: APIKeyScopes;
+    description: string;
+    checked: boolean;
+};
+
+type ScopesByCategory = Record<APIKeyCategories, ScopeChoice[]>;
+
+export function getScopeChoices(
+    keyType: APIKeyUsageOrigin,
+    enviornment: Environment,
+    activeProject: PrimitiveProperties<DeveloperProject>,
+    keyScopes: APIKeyScopes[] = []
+) {
+    const scopesMap: APIKeyScopeDetails<APIKeyScopes>[] =
+        keyType === "server" ? SERVER_API_KEY_PUBLIC_SCOPES : CLIENT_API_KEY_PUBLIC_SCOPES;
+
+    const scopesByCategory = scopesMap.reduce<ScopesByCategory>((memo, item) => {
+        const { title, description, value, category } = item;
+
+        if (!memo[category]) {
+            memo[category] = [];
+        }
+        if (!isScopeDisabled(item, enviornment, activeProject)) {
+            memo[category].push({
+                name: `${title} (${value})`,
+                value,
+                description,
+                checked: keyScopes.includes(value),
+            });
+        }
+        return memo;
+    }, {} as ScopesByCategory);
+
+    return Object.entries(scopesByCategory).flatMap(([category, scopes]) => {
+        return [new Separator(APIKeyCategoryNames[category as APIKeyCategories]), ...scopes];
+    });
+}
+
+function isScopeDisabled(
+    scope: APIKeyScopeDetails<APIKeyScopes>,
+    enviornment: Environment,
+    activeProject: PrimitiveProperties<DeveloperProject>
+) {
+    return (
+        enviornment === "production" &&
+        scope.projectPermission != null &&
+        activeProject?.addons != null &&
+        !activeProject.addons[scope.projectPermission]
+    );
+}

package/src/utils/spinner.ts

@@ -0,0 +1,20 @@
+import { createSpinner as createNanoSpinner } from "nanospinner";
+
+export function createSpinner(initialMessage?: string) {
+    const nanoSpinner = createNanoSpinner(initialMessage);
+    const spinner = {
+        start: (message?: string) => {
+            nanoSpinner.start({ text: message });
+            return spinner;
+        },
+        succeed: (message: string) => {
+            nanoSpinner.success({ text: message });
+            return spinner;
+        },
+        fail: (message: string) => {
+            nanoSpinner.error({ text: message });
+            return spinner;
+        },
+    };
+    return spinner;
+}

package/src/utils/store.ts

@@ -0,0 +1,38 @@
+import { Environment } from "./urls";
+import * as storage from "./keytar";
+
+export function setEnvironment(environment: Environment) {
+    return storage.set("environment", environment);
+}
+
+export async function getEnvironment() {
+    return storage.get("environment") as Promise<Environment | null>;
+}
+
+export async function deleteEnvironment() {
+    return storage.del("environment");
+}
+
+export function setSessionToken(sessionToken: string) {
+    return storage.set("sessionToken", sessionToken);
+}
+
+export async function getSessionToken() {
+    return storage.get("sessionToken") as Promise<string | null>;
+}
+
+export async function deleteSessionToken() {
+    return storage.del("sessionToken");
+}
+
+export function setProjectId(projectId: string) {
+    return storage.set("projectId", projectId);
+}
+
+export async function getProjectId() {
+    return storage.get("projectId") as Promise<string | null>;
+}
+
+export async function deleteProjectId() {
+    return storage.del("projectId");
+}

package/src/utils/urls.ts

@@ -0,0 +1,11 @@
+const crossmintUrls = {
+    production: "https://www.crossmint.com",
+    staging: "https://staging.crossmint.com",
+    local: "http://localhost:3000",
+};
+
+export type Environment = keyof typeof crossmintUrls;
+
+export function getCrossmintUrl(environment: Environment) {
+    return crossmintUrls[environment];
+}

package/tsconfig.json

@@ -0,0 +1,35 @@
+{
+    "extends": "@crossmint/tsconfig/base.json",
+    "compilerOptions": {
+        "composite": true,
+        "paths": {
+            "@/*": ["./src/*"]
+        },
+        "outDir": "dist",
+        "rootDir": "src"
+    },
+    "include": ["src"],
+    "references": [
+        {
+            "path": "../../libraries/common/consts"
+        },
+        {
+            "path": "../../libraries/common/string-utils"
+        },
+        {
+            "path": "../../libraries/common/types"
+        },
+        {
+            "path": "../../libraries/datasources/databases/types"
+        },
+        {
+            "path": "../../libraries/infra-configs/tsup"
+        },
+        {
+            "path": "../../libraries/infra-configs/vitest"
+        },
+        {
+            "path": "../../libraries/products/console/types"
+        }
+    ]
+}