@angeloashmore/prismic-cli-poc 0.0.0-canary.1143872

package/src/slice-set-screenshot.ts

@@ -0,0 +1,235 @@
+import { createHash } from "node:crypto";
+import { readFile, writeFile } from "node:fs/promises";
+import { extname } from "node:path";
+import { parseArgs } from "node:util";
+import * as v from "valibot";
+
+import { isAuthenticated } from "./lib/auth";
+import { safeGetRepositoryFromConfig } from "./lib/config";
+import { stringify } from "./lib/json";
+import { request } from "./lib/request";
+import { findSliceModel } from "./lib/slice";
+
+const HELP = `
+Set a screenshot for a slice variation.
+
+USAGE
+  prismic slice set-screenshot <slice-id> <image-path> [flags]
+
+ARGUMENTS
+  slice-id       Slice identifier (required)
+  image-path     Path to the image file (required)
+
+FLAGS
+  -v, --variation string  Variation ID (default: "default")
+  -r, --repo string       Repository name (uses config if not provided)
+  -h, --help              Show help for command
+
+EXAMPLES
+  prismic slice set-screenshot MySlice ./screenshot.png
+  prismic slice set-screenshot MySlice ./screenshot.png --variation dark
+  prismic slice set-screenshot MySlice ./screenshot.png --repo my-repo
+`.trim();
+
+const ACLCreateResponseSchema = v.object({
+	uploadEndpoint: v.string(),
+	requiredFormDataFields: v.record(v.string(), v.string()),
+	imgixEndpoint: v.string(),
+});
+
+export type UploadScreenshotArgs = {
+	data: Buffer;
+	repo: string;
+	sliceId: string;
+	variationId: string;
+	filename: string;
+};
+
+export async function uploadScreenshot(args: UploadScreenshotArgs): Promise<string> {
+	const { data, repo, sliceId, variationId, filename } = args;
+
+	// Get upload credentials from ACL provider
+	const aclResponse = await request("https://acl-provider.prismic.io/create", {
+		method: "POST",
+		body: {},
+		schema: ACLCreateResponseSchema,
+	});
+
+	if (!aclResponse.ok) {
+		throw new Error("Failed to get upload credentials from Prismic");
+	}
+
+	const { uploadEndpoint, requiredFormDataFields, imgixEndpoint } = aclResponse.value;
+
+	// Generate content digest for unique filename
+	const digest = createHash("md5").update(data).digest("hex");
+	const ext = extname(filename).toLowerCase().slice(1) || "png";
+
+	// Build the S3 key path
+	const key = `${repo}/shared-slices/${sliceId}/${variationId}/${digest}.${ext}`;
+
+	// Create FormData for S3 upload
+	const formData = new FormData();
+	for (const [field, value] of Object.entries(requiredFormDataFields)) {
+		formData.append(field, value);
+	}
+	formData.append("key", key);
+	formData.append("Content-Type", getMimeType(ext));
+	formData.append("file", new Blob([new Uint8Array(data)], { type: getMimeType(ext) }), filename);
+
+	// Upload to S3
+	const uploadResponse = await fetch(uploadEndpoint, {
+		method: "POST",
+		body: formData,
+	});
+
+	if (!uploadResponse.ok) {
+		const text = await uploadResponse.text();
+		throw new Error(`Failed to upload screenshot: ${text}`);
+	}
+
+	// Construct Imgix URL
+	const imgixUrl = `${imgixEndpoint}/${key}?auto=compress,format`;
+
+	return imgixUrl;
+}
+
+function getMimeType(ext: string): string {
+	switch (ext) {
+		case "png":
+			return "image/png";
+		case "jpg":
+		case "jpeg":
+			return "image/jpeg";
+		case "gif":
+			return "image/gif";
+		case "webp":
+			return "image/webp";
+		default:
+			return "image/png";
+	}
+}
+
+export async function sliceSetScreenshot(): Promise<void> {
+	const {
+		values: { help, variation, repo: repoFlag },
+		positionals: [sliceId, imagePath],
+	} = parseArgs({
+		args: process.argv.slice(4), // skip: node, script, "slice", "set-screenshot"
+		options: {
+			variation: { type: "string", short: "v", default: "default" },
+			repo: { type: "string", short: "r" },
+			help: { type: "boolean", short: "h" },
+		},
+		allowPositionals: true,
+	});
+
+	if (help) {
+		console.info(HELP);
+		return;
+	}
+
+	if (!sliceId) {
+		console.error("Missing required argument: slice-id\n");
+		console.error("Usage: prismic slice set-screenshot <slice-id> <image-path>");
+		process.exitCode = 1;
+		return;
+	}
+
+	if (!imagePath) {
+		console.error("Missing required argument: image-path\n");
+		console.error("Usage: prismic slice set-screenshot <slice-id> <image-path>");
+		process.exitCode = 1;
+		return;
+	}
+
+	// Check authentication
+	const authenticated = await isAuthenticated();
+	if (!authenticated) {
+		console.error("You must be logged in to set a screenshot.");
+		console.error("Run `prismic login` to authenticate.");
+		process.exitCode = 1;
+		return;
+	}
+
+	// Resolve repository
+	const repo = repoFlag ?? (await safeGetRepositoryFromConfig());
+	if (!repo) {
+		console.error("Could not determine repository.");
+		console.error("Use --repo flag or run from a directory with prismic.config.json");
+		process.exitCode = 1;
+		return;
+	}
+
+	// Find the slice model
+	const result = await findSliceModel(sliceId);
+	if (!result.ok) {
+		console.error(result.error);
+		process.exitCode = 1;
+		return;
+	}
+
+	const { model, modelPath } = result;
+
+	// Find the variation
+	const variationIndex = model.variations.findIndex((v) => v.id === variation);
+	if (variationIndex === -1) {
+		console.error(`Variation "${variation}" not found in slice "${sliceId}"`);
+		console.error(`Available variations: ${model.variations.map((v) => v.id).join(", ")}`);
+		process.exitCode = 1;
+		return;
+	}
+
+	// Read the image file
+	let imageData: Buffer;
+	try {
+		imageData = await readFile(imagePath);
+	} catch (error) {
+		if (error instanceof Error) {
+			console.error(`Failed to read image file: ${error.message}`);
+		} else {
+			console.error("Failed to read image file");
+		}
+		process.exitCode = 1;
+		return;
+	}
+
+	// Upload the screenshot
+	let imageUrl: string;
+	try {
+		imageUrl = await uploadScreenshot({
+			data: imageData,
+			repo,
+			sliceId,
+			variationId: variation ?? "default",
+			filename: imagePath,
+		});
+	} catch (error) {
+		if (error instanceof Error) {
+			console.error(`Failed to upload screenshot: ${error.message}`);
+		} else {
+			console.error("Failed to upload screenshot");
+		}
+		process.exitCode = 1;
+		return;
+	}
+
+	// Update the model
+	model.variations[variationIndex].imageUrl = imageUrl;
+
+	// Write updated model
+	try {
+		await writeFile(modelPath, stringify(model));
+	} catch (error) {
+		if (error instanceof Error) {
+			console.error(`Failed to update slice model: ${error.message}`);
+		} else {
+			console.error("Failed to update slice model");
+		}
+		process.exitCode = 1;
+		return;
+	}
+
+	console.info(`Screenshot set for slice "${sliceId}" variation "${variation}"`);
+	console.info(`URL: ${imageUrl}`);
+}

package/src/slice-view.ts

@@ -0,0 +1,80 @@
+import { parseArgs } from "node:util";
+
+import { findSliceModel } from "./lib/slice";
+
+const HELP = `
+View details of a specific slice.
+
+USAGE
+  prismic slice view <slice-id> [flags]
+
+ARGUMENTS
+  slice-id     Slice identifier (required)
+
+FLAGS
+  --json       Output as JSON
+  -h, --help   Show help for command
+
+EXAMPLES
+  prismic slice view MySlice
+  prismic slice view MySlice --json
+`.trim();
+
+export async function sliceView(): Promise<void> {
+	const {
+		values: { help, json },
+		positionals: [sliceId],
+	} = parseArgs({
+		args: process.argv.slice(4), // skip: node, script, "slice", "view"
+		options: {
+			json: { type: "boolean" },
+			help: { type: "boolean", short: "h" },
+		},
+		allowPositionals: true,
+	});
+
+	if (help) {
+		console.info(HELP);
+		return;
+	}
+
+	if (!sliceId) {
+		console.error("Missing required argument: slice-id\n");
+		console.error("Usage: prismic slice view <slice-id>");
+		process.exitCode = 1;
+		return;
+	}
+
+	const result = await findSliceModel(sliceId);
+	if (!result.ok) {
+		console.error(result.error);
+		process.exitCode = 1;
+		return;
+	}
+
+	const { model } = result;
+
+	if (json) {
+		console.info(JSON.stringify(model, null, 2));
+		return;
+	}
+
+	console.info(`ID:           ${model.id}`);
+	console.info(`Name:         ${model.name}`);
+	if (model.description) {
+		console.info(`Description:  ${model.description}`);
+	}
+	console.info(`Variations:   ${model.variations.length}`);
+
+	console.info("\nVariations:");
+	for (const variation of model.variations) {
+		const primaryFields = Object.keys(variation.primary ?? {}).length;
+		const itemsFields = Object.keys(variation.items ?? {}).length;
+		console.info(
+			`  - ${variation.id} (${variation.name}): ${primaryFields} primary fields, ${itemsFields} items fields`,
+		);
+		if (variation.imageUrl) {
+			console.info(`    Screenshot: ${variation.imageUrl}`);
+		}
+	}
+}

package/src/slice.ts

@@ -0,0 +1,95 @@
+import { parseArgs } from "node:util";
+
+import { sliceAddField } from "./slice-add-field";
+import { sliceAddVariation } from "./slice-add-variation";
+import { sliceCreate } from "./slice-create";
+import { sliceList } from "./slice-list";
+import { sliceListVariations } from "./slice-list-variations";
+import { sliceRemove } from "./slice-remove";
+import { sliceRemoveField } from "./slice-remove-field";
+import { sliceRemoveVariation } from "./slice-remove-variation";
+import { sliceRename } from "./slice-rename";
+import { sliceSetScreenshot } from "./slice-set-screenshot";
+import { sliceView } from "./slice-view";
+
+const HELP = `
+Manage slices in a Prismic project.
+
+USAGE
+  prismic slice <command> [flags]
+
+COMMANDS
+  create            Create a new slice
+  list              List all slices
+  view              View details of a slice
+  rename            Rename a slice
+  remove            Remove a slice
+  add-field         Add a field to a slice
+  remove-field      Remove a field from a slice
+  add-variation     Add a variation to a slice
+  remove-variation  Remove a variation from a slice
+  list-variations   List all variations of a slice
+  set-screenshot    Set a screenshot for a slice variation
+
+FLAGS
+  -h, --help   Show help for command
+
+LEARN MORE
+  Use \`prismic slice <command> --help\` for more information about a command.
+`.trim();
+
+export async function slice(): Promise<void> {
+	const {
+		positionals: [subcommand],
+	} = parseArgs({
+		args: process.argv.slice(3), // skip: node, script, "slice"
+		options: {
+			help: { type: "boolean", short: "h" },
+		},
+		allowPositionals: true,
+		strict: false,
+	});
+
+	switch (subcommand) {
+		case "create":
+			await sliceCreate();
+			break;
+		case "list":
+			await sliceList();
+			break;
+		case "view":
+			await sliceView();
+			break;
+		case "rename":
+			await sliceRename();
+			break;
+		case "remove":
+			await sliceRemove();
+			break;
+		case "add-field":
+			await sliceAddField();
+			break;
+		case "remove-field":
+			await sliceRemoveField();
+			break;
+		case "add-variation":
+			await sliceAddVariation();
+			break;
+		case "remove-variation":
+			await sliceRemoveVariation();
+			break;
+		case "list-variations":
+			await sliceListVariations();
+			break;
+		case "set-screenshot":
+			await sliceSetScreenshot();
+			break;
+		default: {
+			if (subcommand) {
+				console.error(`Unknown slice subcommand: ${subcommand}\n`);
+				process.exitCode = 1;
+			}
+			console.info(HELP);
+		}
+	}
+}