@prismicio/cli 0.0.1

package/src/cli.ts

@@ -0,0 +1,186 @@
+import { createPrismicManager } from "@prismicio/manager";
+import meow from "meow";
+import * as z from "zod";
+
+import { name as pkgName, version as pkgVersion } from "../package.json";
+
+import { init } from "./commands/init";
+import { sync } from "./commands/sync";
+import { FRAMEWORK_PLUGINS } from "./core/framework";
+import { handleSilentError } from "./utils/error";
+import { displayError, displayHeader } from "./utils/output";
+import { setupSentry, trackSentryError } from "./utils/sentry";
+import { initTelemetry, trackErrorTelemetry } from "./utils/telemetry";
+
+const cli = meow(
+	`
+DOCUMENTATION
+  https://prismic.io/docs
+
+VERSION
+  ${pkgName}@${pkgVersion}
+
+USAGE
+  $ npx prismic@latest init --repository <repository-id>
+  $ npx prismic@latest sync
+
+OPTIONS
+  --repository, -r        Specify a Prismic repository to use when initializing a project
+
+  --help, -h              Display CLI help
+  --version, -v           Display CLI version
+`,
+	{
+		importMeta: import.meta,
+		flags: {
+			repository: {
+				type: "string",
+				shortFlag: "r",
+			},
+			help: {
+				type: "boolean",
+				shortFlag: "h",
+				default: false,
+			},
+			version: {
+				type: "boolean",
+				shortFlag: "v",
+				default: false,
+			},
+		},
+		description: false,
+		autoHelp: false,
+		autoVersion: false,
+		allowUnknownFlags: false,
+	},
+);
+
+export const CLIArgs = z.discriminatedUnion("commandType", [
+	z.object({
+		commandType: z.literal("init"),
+		help: z.boolean().optional(),
+		version: z.boolean().optional(),
+		repository: z
+			.string()
+			.min(1, "Repository name is required to initialize a project"),
+	}),
+	z.object({
+		commandType: z.literal("sync"),
+		help: z.boolean().optional(),
+		version: z.boolean().optional(),
+	}),
+]);
+
+export async function run(): Promise<void> {
+	// Display header immediately so user sees something is happening
+	displayHeader();
+
+	// Setup Sentry as early as possible to track ALL errors
+	setupSentry();
+
+	// Handle help flag (exit early, no telemetry needed)
+	if (cli.flags.help) {
+		cli.showHelp(0);
+		process.exit(0);
+	}
+
+	// Handle version flag (exit early, no telemetry needed)
+	if (cli.flags.version) {
+		console.info(`${pkgName}@${pkgVersion}`);
+		process.exit(0);
+	}
+
+	// Validate CLI arguments first (before any operations that might fail)
+	const cliArgs = CLIArgs.safeParse({
+		...cli.flags,
+		commandType: cli.input[0],
+	});
+
+	// Invalid arguments - track with Sentry even though it's a user error
+	if (!cliArgs.success) {
+		const error = new Error(cliArgs.error.message);
+		displayError(error);
+		await trackSentryError(error);
+		process.exit(1);
+	}
+
+	// Too many arguments - track with Sentry
+	if (cli.input.length > 1) {
+		const error = new Error("Too many arguments. Expected 'init' or 'sync'.");
+		displayError(error);
+		await trackSentryError(error);
+		process.exit(1);
+	}
+
+	// Create manager - wrap in try-catch to track failures
+	let manager;
+	try {
+		manager = createPrismicManager({
+			cwd: process.cwd(),
+			nativePlugins: FRAMEWORK_PLUGINS,
+		});
+	} catch (error) {
+		// Manager creation failed - track with Sentry (telemetry not available yet)
+		displayError(error);
+		await trackSentryError(error);
+		process.exit(1);
+	}
+
+	const commandType = cliArgs.data.commandType;
+	const repositoryName =
+		commandType === "init" ? cliArgs.data.repository : undefined;
+
+	// Initialize telemetry as early as possible (after manager creation)
+	// Track initialization failures with Sentry
+	try {
+		await initTelemetry({
+			manager,
+			commandType,
+			repositoryName,
+		});
+	} catch (telemetryError) {
+		// Telemetry initialization failed - track with Sentry but continue execution
+		// This prevents telemetry issues from breaking the CLI
+		await trackSentryError(telemetryError);
+		handleSilentError(telemetryError, "Telemetry initialization error");
+	}
+
+	// Execute command - all errors here will be tracked
+	try {
+		if (commandType === "init") {
+			await init({
+				manager,
+				repositoryName: cliArgs.data.repository,
+			});
+			process.exit(0);
+		}
+
+		if (commandType === "sync") {
+			await sync({ manager });
+			process.exit(0);
+		}
+
+		throw new Error("Unknown command type.");
+	} catch (error) {
+		displayError(error);
+
+		// Always track with Sentry first (most reliable)
+		await trackSentryError(error);
+
+		// Try to track with telemetry if it was initialized
+		// If telemetry wasn't initialized or tracking fails, Sentry already has it
+		try {
+			await trackErrorTelemetry({
+				manager,
+				error,
+				commandType,
+			});
+		} catch (telemetryError) {
+			handleSilentError(telemetryError, "Telemetry tracking error");
+		}
+
+		process.exit(1);
+	}
+}
+
+void run();

package/src/commands/init.ts

@@ -0,0 +1,68 @@
+import type { PrismicManager } from "@prismicio/manager";
+
+import { version as pkgVersion } from "../../package.json";
+import { login } from "../core/auth";
+import { saveCustomTypes } from "../core/customType";
+import { initFramework } from "../core/framework";
+import {
+	createPrismicConfig,
+	detectProjectContext,
+	detectProjectState,
+} from "../core/project";
+import { validateRepository } from "../core/repository";
+import { saveSlices } from "../core/slices";
+import { checkCLIVersion } from "../core/version";
+import { displaySuccess } from "../utils/output";
+
+type InitArgs = {
+	manager: PrismicManager;
+	repositoryName: string;
+};
+
+export async function init(args: InitArgs): Promise<void> {
+	const { manager, repositoryName } = args;
+
+	// Authentication - Also updates Sentry context
+	await login(manager);
+
+	// Ensure the project is not already initialized
+	await detectProjectState({ manager, commandType: "init" });
+
+	// Ensure the repository exists and the user has write access
+	await validateRepository({ manager, repository: repositoryName });
+
+	// Get project framework and package manager - Also updates Sentry context
+	const projectContext = await detectProjectContext(manager);
+
+	// Check CLI version - Voluntarily late so Sentry context is updated
+	await checkCLIVersion({ manager, currentVersion: pkgVersion });
+
+	// Create Prismic configuration file
+	await createPrismicConfig({ manager, projectContext, repositoryName });
+
+	// Initialize the plugin system
+	await manager.plugins.initPlugins();
+
+	// Initialize the framework specific dependencies and files
+	await initFramework({ manager, projectContext });
+
+	// Save Prismic slices locally
+	await saveSlices({ manager });
+
+	// Save Prismic custom types locally
+	await saveCustomTypes({ manager });
+
+	// Track the end of the init command
+	await manager.telemetry.track({
+		event: "prismic-cli:end",
+		commandType: "init",
+		repository: repositoryName,
+		fullCommand: process.argv.join(" "),
+		success: true,
+	});
+
+	displaySuccess(
+		"Project initialized successfully!",
+		"You're all set to start building with Prismic.",
+	);
+}

package/src/commands/sync.ts

@@ -0,0 +1,58 @@
+import type { PrismicManager } from "@prismicio/manager";
+
+import { version as pkgVersion } from "../../package.json";
+import { login } from "../core/auth";
+import { saveCustomTypes } from "../core/customType";
+import { detectProjectContext, detectProjectState } from "../core/project";
+import { validateRepository } from "../core/repository";
+import { saveSlices } from "../core/slices";
+import { checkCLIVersion } from "../core/version";
+import { displaySuccess } from "../utils/output";
+
+type SyncArgs = {
+	manager: PrismicManager;
+};
+
+export async function sync(args: SyncArgs): Promise<void> {
+	const { manager } = args;
+
+	// Authentication - Also updates Sentry context
+	await login(manager);
+
+	// Ensure the project is already initialized
+	await detectProjectState({ manager, commandType: "sync" });
+
+	// Get repository from Prismic config file
+	const repositoryName = await manager.project.getRepositoryName();
+
+	// Ensure the repository exists and the user has write access
+	await validateRepository({ manager, repository: repositoryName });
+
+	// Ensure validity of the framework and package manager - Also updates Sentry context
+	await detectProjectContext(manager);
+
+	// Check CLI version - Voluntarily late so Sentry context is updated
+	await checkCLIVersion({ manager, currentVersion: pkgVersion });
+
+	// Initialize the plugin system
+	await manager.plugins.initPlugins();
+
+	// Save Prismic slices locally
+	await saveSlices({ manager });
+
+	// Save Prismic custom types locally
+	await saveCustomTypes({ manager });
+
+	await manager.telemetry.track({
+		event: "prismic-cli:end",
+		commandType: "sync",
+		repository: repositoryName,
+		fullCommand: process.argv.join(" "),
+		success: true,
+	});
+
+	displaySuccess(
+		"Sync completed successfully!",
+		"Your local types are up to date.",
+	);
+}

package/src/core/auth.ts

@@ -0,0 +1,98 @@
+import type { PrismicManager } from "@prismicio/manager";
+import chalk from "chalk";
+import open from "open";
+
+import { listr, listrRun } from "../utils/listr";
+import { updateSentryContext } from "../utils/sentry";
+
+export async function login(manager: PrismicManager): Promise<void> {
+	return listrRun([
+		{
+			title: "Logging in to Prismic...",
+			task: async (_, parentTask) => {
+				const isLoggedIn = await manager.user.checkIsLoggedIn();
+
+				if (!isLoggedIn) {
+					parentTask.title = getLoggingInTitle(
+						chalk.cyan("Press any key to open the browser to login..."),
+					);
+					await pressKeyToLogin();
+					await waitingForLogin(manager, ({ url }) => {
+						parentTask.title = getLoggingInTitle(
+							chalk.cyan("Opening browser, waiting for you to login..."),
+							chalk.yellow(
+								"If your browser did not open automatically, please use the url below:",
+							),
+							url,
+						);
+					});
+				}
+
+				parentTask.title = `Logged in`;
+
+				return listr(
+					[
+						{
+							title: "Fetching user profile...",
+							task: async (_, task) => {
+								const userProfile = await manager.user.getProfile();
+
+								// Identify the user for Amplitude
+								await manager.telemetry.identify(userProfile);
+
+								// Update Sentry context for the current user
+								updateSentryContext({ userProfile });
+
+								parentTask.title = `Logged in as ${chalk.cyan(
+									userProfile?.email,
+								)}`;
+								task.title = "Fetched user profile";
+							},
+						},
+					],
+					{ concurrent: true },
+				);
+			},
+		},
+	]);
+}
+
+function getLoggingInTitle(subtitle?: string, ...extra: string[]): string {
+	return `Logging in to Prismic...
+    
+███████████████████████████████████████████████████████████████████████████
+
+${subtitle ? `* * ${subtitle}` : ""}
+${extra.length ? `\n${extra.map((line) => `   ${line}`).join("\n")}\n` : ""}
+███████████████████████████████████████████████████████████████████████████
+`;
+}
+
+async function pressKeyToLogin(): Promise<void> {
+	await new Promise((resolve) => {
+		const initialRawMode = !!process.stdin.isRaw;
+		process.stdin.setRawMode?.(true);
+		process.stdin.resume();
+		process.stdin.once("data", (data: Buffer) => {
+			process.stdin.setRawMode?.(initialRawMode);
+			process.stdin.pause();
+			resolve(data.toString("utf-8"));
+		});
+	});
+}
+
+async function waitingForLogin(
+	manager: PrismicManager,
+	onListenCallback?: (
+		sessionInfo: Awaited<ReturnType<typeof manager.user.getLoginSessionInfo>>,
+	) => void,
+): Promise<void> {
+	const sessionInfo = await manager.user.getLoginSessionInfo();
+	await manager.user.nodeLoginSession({
+		port: sessionInfo.port,
+		onListenCallback() {
+			open(sessionInfo.url);
+			onListenCallback?.(sessionInfo);
+		},
+	});
+}

package/src/core/customType.ts

@@ -0,0 +1,64 @@
+import type { PrismicManager } from "@prismicio/manager";
+
+import { listrRun } from "../utils/listr";
+
+type SaveCustomTypesArgs = {
+	manager: PrismicManager;
+};
+
+export async function saveCustomTypes(
+	args: SaveCustomTypesArgs,
+): Promise<void> {
+	const { manager } = args;
+
+	await listrRun([
+		{
+			title: "Fetching Prismic custom types...",
+			task: async (_, parentTask) => {
+				const customTypes = await manager.customTypes.fetchRemoteCustomTypes();
+
+				parentTask.title = "Saving Prismic custom types changes...";
+
+				const localCustomTypes = await manager.customTypes.readAllCustomTypes();
+
+				// Handle custom types update
+				for (const remoteCustomType of customTypes) {
+					const existsLocally = localCustomTypes.models.some(
+						(local) => local.model.id === remoteCustomType.id,
+					);
+					if (existsLocally) {
+						await manager.customTypes.updateCustomType({
+							model: remoteCustomType,
+						});
+					}
+				}
+
+				// Handle custom types deletion
+				for (const localCustomType of localCustomTypes.models) {
+					const existsRemotely = customTypes.some(
+						(remote) => remote.id === localCustomType.model.id,
+					);
+					if (!existsRemotely) {
+						await manager.customTypes.deleteCustomType({
+							id: localCustomType.model.id,
+						});
+					}
+				}
+
+				// Handle custom types creation
+				for (const remoteCustomType of customTypes) {
+					const existsLocally = localCustomTypes.models.some(
+						(local) => local.model.id === remoteCustomType.id,
+					);
+					if (!existsLocally) {
+						await manager.customTypes.createCustomType({
+							model: remoteCustomType,
+						});
+					}
+				}
+
+				parentTask.title = "Prismic custom types changes saved";
+			},
+		},
+	]);
+}

package/src/core/framework.ts

@@ -0,0 +1,180 @@
+import { readFile, readdir, rm } from "node:fs/promises";
+import { join } from "node:path";
+
+import adapterNextPlugin from "@prismicio/adapter-next";
+import adapterNuxtPlugin from "@prismicio/adapter-nuxt";
+import adapterNuxt2Plugin from "@prismicio/adapter-nuxt2";
+import adapterSveltekitPlugin from "@prismicio/adapter-sveltekit";
+import { type PrismicManager } from "@prismicio/manager";
+import semver from "semver";
+
+import { listrRun } from "../utils/listr";
+
+import { type ProjectContext } from "./project";
+
+export type Framework = {
+	/**
+	 * Framework's human readable name.
+	 */
+	name: string;
+
+	/**
+	 * Framework 's id sent to Segment from Slice Machine
+	 */
+	telemetryID: "next" | "nuxt-2" | "nuxt" | "sveltekit-1" | "sveltekit-2";
+
+	/**
+	 * Package name of the adapter responsible for this framework
+	 */
+	adapterName: string;
+
+	/**
+	 * A package name/semver range map defining framework compatibility
+	 * requirements.
+	 *
+	 * Project should match all entries to be considered compatible.
+	 */
+	compatibility: Record<string, string>;
+};
+
+/**
+ * Frameworks we support, orders shouldn't matter much but is respected (the
+ * higher it is the more priority it has in case multiple matches)
+ */
+export const FRAMEWORKS: Record<string, Framework> = {
+	"nuxt-2": {
+		name: "Nuxt 2",
+		telemetryID: "nuxt-2",
+		adapterName: "@prismicio/adapter-nuxt2",
+		compatibility: {
+			nuxt: "^2.0.0",
+		},
+	},
+	nuxt: {
+		name: "Nuxt",
+		telemetryID: "nuxt",
+		adapterName: "@prismicio/adapter-nuxt",
+		compatibility: {
+			nuxt: "^3.0.0 || ^4.0.0",
+		},
+	},
+	next: {
+		name: "Next.js",
+		telemetryID: "next",
+		adapterName: "@prismicio/adapter-next",
+		compatibility: {
+			next: "^11 || ^12 || ^13 || ^14 || ^15 || ^16.0.0-beta.0",
+		},
+	},
+	"sveltekit-1": {
+		name: "SvelteKit",
+		telemetryID: "sveltekit-1",
+		adapterName: "@prismicio/adapter-sveltekit",
+		compatibility: {
+			"@sveltejs/kit": "^1.0.0",
+		},
+	},
+	"sveltekit-2": {
+		name: "SvelteKit",
+		telemetryID: "sveltekit-2",
+		adapterName: "@prismicio/adapter-sveltekit",
+		compatibility: {
+			"@sveltejs/kit": "^2.0.0",
+		},
+	},
+} as const;
+
+export const detectFramework = async (cwd: string): Promise<Framework> => {
+	const path = join(cwd, "package.json");
+
+	let allDependencies: Record<string, string>;
+	try {
+		const pkg = JSON.parse(await readFile(path, "utf-8"));
+
+		allDependencies = {
+			...pkg.dependencies,
+			...pkg.devDependencies,
+		};
+	} catch (error) {
+		throw new Error(
+			`Failed to read project's \`package.json\` at \`${path}\``,
+			{ cause: error },
+		);
+	}
+
+	const framework = Object.values(FRAMEWORKS).find((framework) => {
+		return Object.entries(framework.compatibility).every(([pkg, range]) => {
+			if (pkg in allDependencies) {
+				try {
+					// Determine lowest version possibly in use
+					const minimumVersion = semver.minVersion(allDependencies[pkg]);
+
+					return semver.satisfies(minimumVersion!, range);
+				} catch {
+					// We assume unconventional tags, `latest`, `beta`, `dev` matches the framework
+					return true;
+				}
+			}
+
+			return false;
+		});
+	});
+
+	if (!framework) {
+		throw new Error("No framework compatible with Prismic was found.");
+	}
+
+	return framework;
+};
+
+type InitFrameworkArgs = {
+	manager: PrismicManager;
+	projectContext: ProjectContext;
+};
+
+export async function initFramework(args: InitFrameworkArgs): Promise<void> {
+	const { manager, projectContext } = args;
+	const { framework } = projectContext;
+
+	await listrRun([
+		{
+			title: `Initializing project for ${framework.name}...`,
+			task: async (_, parentTask) => {
+				const updateOutput = (data: Buffer | string | null) => {
+					if (data instanceof Buffer) {
+						parentTask.output = data.toString();
+					} else if (typeof data === "string") {
+						parentTask.output = data;
+					}
+				};
+				await manager.project.initProject({
+					log: updateOutput,
+				});
+
+				// TODO: Export simulator management out of adapter and remove this code
+				const projectRoot = await manager.project.getRoot();
+				const entries = await readdir(projectRoot, {
+					recursive: true,
+					withFileTypes: true,
+				});
+				for (const entry of entries) {
+					if (entry.isDirectory() && entry.name === "slice-simulator") {
+						await rm(join(entry.path, entry.name), {
+							recursive: true,
+							force: true,
+						});
+					}
+				}
+
+				parentTask.title = `Updated project for ${framework.name}`;
+			},
+		},
+	]);
+}
+
+export const FRAMEWORK_PLUGINS = {
+	"@prismicio/adapter-next": adapterNextPlugin,
+	"@prismicio/adapter-nuxt": adapterNuxtPlugin,
+	"@prismicio/adapter-nuxt2": adapterNuxt2Plugin,
+	"@prismicio/adapter-sveltekit": adapterSveltekitPlugin,
+};