bsmnt 0.0.0

package/src/commands/setup-sanity.js

@@ -0,0 +1,426 @@
+import { execFileSync, execSync } from "node:child_process";
+import path from "node:path";
+import fs from "fs-extra";
+import ora from "ora";
+import pc from "picocolors";
+import prompts from "prompts";
+
+/**
+ * Strip ANSI escape codes from a string (covers all SGR and cursor sequences).
+ */
+function stripAnsi(str) {
+	// biome-ignore lint/suspicious/noControlCharactersInRegex: ANSI codes need control chars
+	const ansiRegex = /\u001b\[[0-9;?]*[A-Za-z]/g;
+	return str.replace(ansiRegex, "");
+}
+/**
+ * Step 1: Verify Sanity CLI is available
+ */
+function verifySanityCli() {
+	try {
+		execSync("npx --yes sanity --version", { stdio: "pipe", timeout: 30000 });
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Step 2: Verify user is authenticated with Sanity
+ */
+function verifyAuth() {
+	try {
+		execSync("npx --yes sanity projects list", {
+			stdio: "pipe",
+			timeout: 30000,
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Fetch the user's Sanity organizations via the Management API.
+ */
+async function fetchOrganizations(authToken) {
+	const response = await fetch(
+		"https://api.sanity.io/v2021-06-07/organizations",
+		{
+			headers: { Authorization: `Bearer ${authToken}` },
+			signal: AbortSignal.timeout(15000),
+		},
+	);
+
+	if (!response.ok) {
+		throw new Error(`Failed to fetch organizations (${response.status})`);
+	}
+
+	return response.json();
+}
+
+/**
+ * Step 3: Create a Sanity project and return the project ID.
+ * Uses execFileSync to avoid shell injection via project name.
+ */
+function createSanityProject(projectName, organizationId) {
+	const args = [
+		"--yes",
+		"sanity",
+		"projects",
+		"create",
+		"--name",
+		projectName,
+		"--dataset",
+		"production",
+	];
+	if (organizationId) {
+		args.push("--organization", organizationId);
+	}
+
+	const output = execFileSync("npx", args, {
+		encoding: "utf-8",
+		timeout: 120000,
+	});
+
+	const match = stripAnsi(output).match(/ID:\s*(\S+)/);
+	if (!match) {
+		throw new Error(
+			`Could not parse project ID from Sanity CLI output:\n${output}`,
+		);
+	}
+
+	return match[1];
+}
+
+/**
+ * Step 4: Get the user's Sanity auth token from the CLI.
+ */
+function getAuthToken() {
+	const output = execSync("npx --yes sanity debug --secrets 2>&1", {
+		encoding: "utf-8",
+		timeout: 30000,
+	});
+
+	const clean = stripAnsi(output);
+	const match = clean.match(/Auth token:\s*'([^']+)'/);
+	if (!match) {
+		throw new Error("Could not extract auth token from Sanity CLI.");
+	}
+
+	return match[1];
+}
+
+/**
+ * Step 5: Create an API read token via the Sanity HTTP API.
+ * Uses native fetch to avoid shell injection and curl dependency.
+ */
+async function createApiToken(projectId, authToken) {
+	const url = `https://api.sanity.io/v2021-06-07/projects/${encodeURIComponent(projectId)}/tokens`;
+
+	const response = await fetch(url, {
+		method: "POST",
+		headers: {
+			Authorization: `Bearer ${authToken}`,
+			"Content-Type": "application/json",
+		},
+		body: JSON.stringify({
+			label: "Viewer private token",
+			roleName: "viewer",
+		}),
+		signal: AbortSignal.timeout(30000),
+	});
+
+	const data = await response.json();
+
+	if (response.status === 401 || response.status === 403) {
+		throw new Error("Auth token expired or invalid. Run: npx sanity login");
+	}
+
+	if (!response.ok) {
+		throw new Error(
+			`Sanity API error (${response.status}): ${JSON.stringify(data, null, 2)}`,
+		);
+	}
+
+	if (!data.key) {
+		throw new Error(
+			`Failed to create API token. Response:\n${JSON.stringify(data, null, 2)}`,
+		);
+	}
+
+	return data.key;
+}
+
+/**
+ * Step 6: Write .env.local with Sanity credentials.
+ * Appends to existing file if present.
+ */
+async function writeEnvLocal(targetDir, projectId, apiToken) {
+	const envPath = path.join(targetDir, ".env.local");
+
+	const sanityBlock = `# Sanity CMS
+NEXT_PUBLIC_SANITY_PROJECT_ID=${projectId}
+NEXT_PUBLIC_SANITY_DATASET=production
+SANITY_PRIVATE_TOKEN=${apiToken}
+NEXT_PUBLIC_SANITY_API_READ_TOKEN=${apiToken}
+`;
+
+	if (fs.existsSync(envPath)) {
+		const existing = await fs.readFile(envPath, "utf-8");
+		if (existing.includes("NEXT_PUBLIC_SANITY_PROJECT_ID")) {
+			return;
+		}
+		await fs.appendFile(envPath, `\n${sanityBlock}`);
+	} else {
+		await fs.writeFile(envPath, sanityBlock);
+	}
+}
+
+/**
+ * Step 7: Verify the connection to Sanity by querying the API.
+ * Uses native fetch instead of curl.
+ */
+async function verifyConnection(projectId, apiToken) {
+	try {
+		const url = `https://${encodeURIComponent(projectId)}.api.sanity.io/v2024-03-15/data/query/production?query=*%5B0%5D`;
+
+		const response = await fetch(url, {
+			headers: { Authorization: `Bearer ${apiToken}` },
+			signal: AbortSignal.timeout(15000),
+		});
+
+		const data = await response.json();
+		return Object.hasOwn(data, "result");
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Step 8: Ensure .env.local is in .gitignore.
+ */
+async function ensureGitignore(targetDir) {
+	const gitignorePath = path.join(targetDir, ".gitignore");
+
+	let content = "";
+	if (fs.existsSync(gitignorePath)) {
+		content = await fs.readFile(gitignorePath, "utf-8");
+	}
+
+	if (!content.includes(".env.local")) {
+		const newline = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
+		await fs.writeFile(gitignorePath, `${content + newline}.env.local\n`);
+	}
+}
+
+/**
+ * Main entry point: Automate Sanity project creation, token setup, and .env.local generation.
+ *
+ * @param {string} targetDir - The project directory
+ * @param {object} [options] - Optional overrides
+ * @param {string} [options.projectName] - Pre-set project name (skip prompt)
+ */
+export async function setupSanityProject(targetDir, options = {}) {
+	console.log();
+
+	const { wantSetup } = await prompts({
+		type: "confirm",
+		name: "wantSetup",
+		message:
+			"Set up Sanity project automatically? (creates project, tokens, .env.local)",
+		initial: true,
+	});
+
+	if (!wantSetup) {
+		console.log(pc.dim("  Skipped. You can set up Sanity manually later.\n"));
+		return false;
+	}
+
+	// Step 1: Verify Sanity CLI
+	const cliSpinner = ora("Checking Sanity CLI...").start();
+	if (!verifySanityCli()) {
+		cliSpinner.fail(
+			pc.red(
+				"Sanity CLI not available. Make sure sanity packages are installed.",
+			),
+		);
+		console.log(
+			pc.dim(
+				"  Run: bun add next-sanity @sanity/client @sanity/image-url sanity @sanity/vision\n",
+			),
+		);
+		return false;
+	}
+	cliSpinner.succeed(pc.green("Sanity CLI available."));
+
+	// Step 2: Verify authentication
+	const authSpinner = ora("Verifying Sanity authentication...").start();
+	if (!verifyAuth()) {
+		authSpinner.info(pc.yellow("Not logged in. Opening Sanity login..."));
+		try {
+			execSync("npx --yes sanity login", { stdio: "inherit" });
+		} catch {
+			// login command failed or user cancelled
+		}
+		const retrySpinner = ora("Re-verifying Sanity authentication...").start();
+		if (!verifyAuth()) {
+			retrySpinner.fail(pc.red("Still not logged in to Sanity."));
+			console.log(pc.yellow("  Run: npx sanity login"));
+			console.log(
+				pc.dim(
+					"  This opens a browser for authentication. Re-run this command after logging in.\n",
+				),
+			);
+			return false;
+		}
+		retrySpinner.succeed(pc.green("Authenticated with Sanity."));
+	} else {
+		authSpinner.succeed(pc.green("Authenticated with Sanity."));
+	}
+
+	// Step 3: Get auth token (needed for org selection and API token creation)
+	const tokenSpinner = ora("Retrieving auth token...").start();
+	let authToken;
+	try {
+		authToken = getAuthToken();
+		tokenSpinner.succeed(pc.green("Auth token retrieved."));
+	} catch (e) {
+		tokenSpinner.fail(pc.red(`Failed to get auth token: ${e.message}`));
+		console.log(pc.dim("  Fallback: check ~/.config/sanity/config.json\n"));
+		return false;
+	}
+
+	// Step 4: Select organization
+	let organizationId = null;
+	try {
+		const orgSpinner = ora("Fetching organizations...").start();
+		const organizations = await fetchOrganizations(authToken);
+
+		if (organizations.length > 0) {
+			orgSpinner.succeed(
+				pc.green(
+					`Found ${organizations.length} organization${organizations.length > 1 ? "s" : ""}.`,
+				),
+			);
+
+			const choices = [
+				{ title: "Personal account", value: null },
+				...organizations.map((org) => ({
+					title: org.name,
+					description: org.slug || org.id,
+					value: org.id,
+				})),
+			];
+
+			const { selectedOrg } = await prompts({
+				type: "select",
+				name: "selectedOrg",
+				message: "Which organization should own this project?",
+				choices,
+				initial: organizations.length === 1 ? 1 : 0,
+			});
+
+			if (selectedOrg === undefined) {
+				console.log(pc.yellow("\n  Setup cancelled.\n"));
+				return false;
+			}
+
+			organizationId = selectedOrg;
+		} else {
+			orgSpinner.succeed(pc.green("Using personal account."));
+		}
+	} catch (_e) {
+		// Non-critical: fall back to no org (personal account)
+		console.log(
+			pc.dim("  Could not fetch organizations, using personal account."),
+		);
+	}
+
+	// Step 5: Get project name and create project
+	const dirName = path.basename(targetDir);
+	const projectName =
+		options.projectName ||
+		(
+			await prompts({
+				type: "text",
+				name: "name",
+				message: "Sanity project name?",
+				initial: dirName,
+				validate: (v) => (v.length > 0 ? true : "Project name is required"),
+			})
+		).name;
+
+	if (!projectName) {
+		console.log(pc.yellow("\n  Setup cancelled.\n"));
+		return false;
+	}
+
+	const projectSpinner = ora(
+		`Creating Sanity project "${pc.cyan(projectName)}"${organizationId ? ` in organization` : ""}...`,
+	).start();
+
+	let projectId;
+	try {
+		projectId = createSanityProject(projectName, organizationId);
+		projectSpinner.succeed(
+			pc.green(`Sanity project created: ${pc.cyan(projectId)}`),
+		);
+	} catch (e) {
+		projectSpinner.fail(pc.red(`Failed to create project: ${e.message}`));
+		return false;
+	}
+
+	// Step 6: Create API read token
+	const apiSpinner = ora("Creating API read token...").start();
+	let apiToken;
+	try {
+		apiToken = await createApiToken(projectId, authToken);
+		apiSpinner.succeed(pc.green("API read token created."));
+	} catch (e) {
+		apiSpinner.fail(pc.red(`Failed to create API token: ${e.message}`));
+		return false;
+	}
+
+	// Step 7: Write .env.local
+	const envSpinner = ora("Writing .env.local...").start();
+	try {
+		await writeEnvLocal(targetDir, projectId, apiToken);
+		envSpinner.succeed(
+			pc.green(".env.local configured with Sanity credentials."),
+		);
+	} catch (e) {
+		envSpinner.fail(pc.red(`Failed to write .env.local: ${e.message}`));
+		return false;
+	}
+
+	// Step 8: Verify connection
+	const verifySpinner = ora("Verifying Sanity connection...").start();
+	const connected = await verifyConnection(projectId, apiToken);
+	if (connected) {
+		verifySpinner.succeed(pc.green("Sanity connection verified."));
+	} else {
+		verifySpinner.warn(
+			pc.yellow(
+				"Could not verify connection. Check credentials after bun install.",
+			),
+		);
+	}
+
+	// Step 9: Ensure .env.local is gitignored
+	try {
+		await ensureGitignore(targetDir);
+	} catch {
+		// Non-critical, don't block
+	}
+
+	console.log(
+		pc.green(`\n  Sanity project "${projectName}" (${projectId}) is ready.`),
+	);
+	console.log(
+		pc.dim(`  Manage at: https://sanity.io/manage/project/${projectId}`),
+	);
+	console.log(pc.dim("  Studio will be available at: /studio\n"));
+
+	return true;
+}