@salesforce/storefront-next-dev 0.1.1 → 0.2.0-alpha.1

package/dist/local-dev-setup.js

@@ -0,0 +1,176 @@
+import { c as warn, r as info, s as success } from "./logger.js";
+import path from "path";
+import fs from "fs-extra";
+import prompts from "prompts";
+
+//#region src/utils/local-dev-setup.ts
+/**
+* Prepares a cloned template for standalone use outside the monorepo.
+* Prompts user for local package paths and replaces workspace:* dependencies with file: references.
+*/
+async function prepareForLocalDev(options) {
+	const { projectDirectory, sourcePackagesDir } = options;
+	const packageJsonPath = path.join(projectDirectory, "package.json");
+	if (!fs.existsSync(packageJsonPath)) throw new Error(`package.json not found in ${projectDirectory}`);
+	const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+	const workspaceDeps = [];
+	for (const depType of [
+		"dependencies",
+		"devDependencies",
+		"peerDependencies"
+	]) {
+		const deps = packageJson[depType];
+		if (!deps) continue;
+		for (const [pkg, version] of Object.entries(deps)) if (typeof version === "string" && version.startsWith("workspace:")) workspaceDeps.push({
+			pkg,
+			depType
+		});
+	}
+	if (workspaceDeps.length === 0) {
+		info("No workspace:* dependencies found. Project is ready for standalone use.");
+		return;
+	}
+	console.log("\n🔗 Found workspace dependencies that need to be linked to local packages:\n");
+	for (const { pkg } of workspaceDeps) console.log(`   • ${pkg}`);
+	console.log("");
+	const defaultPaths = {};
+	if (sourcePackagesDir) {
+		defaultPaths["@salesforce/storefront-next-dev"] = path.join(sourcePackagesDir, "storefront-next-dev");
+		defaultPaths["@salesforce/storefront-next-runtime"] = path.join(sourcePackagesDir, "storefront-next-runtime");
+	}
+	const resolvedPaths = {};
+	for (const { pkg } of workspaceDeps) {
+		if (resolvedPaths[pkg]) continue;
+		const defaultPath = defaultPaths[pkg] || "";
+		const defaultExists = defaultPath && fs.existsSync(defaultPath);
+		const { localPath } = await prompts({
+			type: "text",
+			name: "localPath",
+			message: `📦 Path to ${pkg}:`,
+			initial: defaultExists ? defaultPath : "",
+			validate: (value) => {
+				if (!value) return "Path is required";
+				if (!fs.existsSync(value)) return `Directory not found: ${value}`;
+				if (!fs.existsSync(path.join(value, "package.json"))) return `No package.json found in: ${value}`;
+				return true;
+			}
+		});
+		if (!localPath) {
+			warn(`Skipping ${pkg} - no path provided`);
+			continue;
+		}
+		resolvedPaths[pkg] = localPath;
+	}
+	let modified = false;
+	for (const depType of [
+		"dependencies",
+		"devDependencies",
+		"peerDependencies"
+	]) {
+		const deps = packageJson[depType];
+		if (!deps) continue;
+		for (const [pkg, version] of Object.entries(deps)) if (typeof version === "string" && version.startsWith("workspace:")) {
+			const localPath = resolvedPaths[pkg];
+			if (localPath) {
+				const fileRef = `file:${localPath}`;
+				info(`Linked ${pkg} → ${fileRef}`);
+				deps[pkg] = fileRef;
+				modified = true;
+			} else {
+				warn(`Removing unresolved workspace dependency: ${pkg}`);
+				delete deps[pkg];
+				modified = true;
+			}
+		}
+	}
+	if (packageJson.volta?.extends) {
+		delete packageJson.volta.extends;
+		if (Object.keys(packageJson.volta).length === 0) delete packageJson.volta;
+		modified = true;
+	}
+	if (modified) {
+		fs.writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 4)}\n`);
+		success("package.json updated with local package links");
+		patchViteConfigForLinkedPackages(projectDirectory, Object.keys(resolvedPaths));
+	}
+}
+/**
+* Patches vite.config.ts to fix "You must render this element inside a <HydratedRouter>" errors
+* that occur when using file: linked packages.
+*
+* The fix adds:
+* 1. resolve.dedupe for react, react-dom, react-router (helps with non-linked duplicates)
+* 2. ssr.noExternal for file-linked packages (key fix - bundles them so they use host's dependencies)
+*
+* When packages are in ssr.noExternal, Vite bundles them during SSR instead of externalizing.
+* During bundling, their imports resolve through the host project's node_modules,
+* ensuring all code uses the same react-router instance with the same context.
+*/
+function patchViteConfigForLinkedPackages(projectDirectory, linkedPackages) {
+	const viteConfigPath = path.join(projectDirectory, "vite.config.ts");
+	if (!fs.existsSync(viteConfigPath)) {
+		warn("vite.config.ts not found, skipping patch for file-linked packages");
+		return;
+	}
+	if (linkedPackages.length === 0) return;
+	let viteConfig = fs.readFileSync(viteConfigPath, "utf8");
+	let modified = false;
+	if (!viteConfig.includes("dedupe:")) {
+		const resolveMatch = viteConfig.match(/resolve:\s*\{/);
+		if (resolveMatch && resolveMatch.index !== void 0) {
+			const insertPos = resolveMatch.index + resolveMatch[0].length;
+			viteConfig = viteConfig.slice(0, insertPos) + `
+            // Deduplicates packages to prevent context issues with file-linked packages
+            dedupe: ['react', 'react-dom', 'react-router'],` + viteConfig.slice(insertPos);
+			modified = true;
+		}
+	}
+	const packageList = linkedPackages.map((p) => `'${p}'`).join(", ");
+	if (/ssr:\s*\{[^}]*noExternal:/.test(viteConfig)) {
+		const noExternalArrayRegex = /noExternal:\s*\[([^\]]*)\]/;
+		const noExternalMatch = viteConfig.match(noExternalArrayRegex);
+		if (noExternalMatch) {
+			const existingPackages = noExternalMatch[1];
+			const packagesToAdd = linkedPackages.filter((p) => !existingPackages.includes(p));
+			if (packagesToAdd.length > 0) {
+				const newPackageList = packagesToAdd.map((p) => `'${p}'`).join(", ");
+				const newArray = existingPackages.trim() ? `[${existingPackages.trim()}, ${newPackageList}]` : `[${newPackageList}]`;
+				viteConfig = viteConfig.replace(noExternalArrayRegex, `noExternal: ${newArray}`);
+				modified = true;
+			}
+		}
+	} else {
+		const ssrMatch = viteConfig.match(/ssr:\s*\{/);
+		if (ssrMatch && ssrMatch.index !== void 0) {
+			const insertPos = ssrMatch.index + ssrMatch[0].length;
+			const noExternalBlock = `
+            // Bundle file-linked packages so they use host project's dependencies
+            // This prevents "You must render this element inside a <HydratedRouter>" errors
+            noExternal: [${packageList}],`;
+			viteConfig = viteConfig.slice(0, insertPos) + noExternalBlock + viteConfig.slice(insertPos);
+			modified = true;
+		} else {
+			const returnMatch = viteConfig.match(/return\s*\{/);
+			if (returnMatch && returnMatch.index !== void 0) {
+				const insertPos = returnMatch.index + returnMatch[0].length;
+				const ssrBlock = `
+        // SSR config for file-linked packages
+        ssr: {
+            // Bundle file-linked packages so they use host project's dependencies
+            // This prevents "You must render this element inside a <HydratedRouter>" errors
+            noExternal: [${packageList}],
+            target: 'node',
+        },`;
+				viteConfig = viteConfig.slice(0, insertPos) + ssrBlock + viteConfig.slice(insertPos);
+				modified = true;
+			}
+		}
+	}
+	if (modified) {
+		fs.writeFileSync(viteConfigPath, viteConfig);
+		success("vite.config.ts patched for file-linked packages (ssr.noExternal + resolve.dedupe)");
+	} else info("vite.config.ts already configured for file-linked packages");
+}
+
+//#endregion
+export { prepareForLocalDev as t };

package/dist/logger.js

@@ -0,0 +1,105 @@
+import os from "os";
+import chalk from "chalk";
+import { createRequire } from "module";
+
+//#region package.json
+var version = "0.2.0-alpha.1";
+
+//#endregion
+//#region src/utils/logger.ts
+/**
+* Get the local network IPv4 address
+*/
+function getNetworkAddress() {
+	const interfaces = os.networkInterfaces();
+	for (const name of Object.keys(interfaces)) {
+		const iface = interfaces[name];
+		if (!iface) continue;
+		for (const alias of iface) if (alias.family === "IPv4" && !alias.internal) return alias.address;
+	}
+}
+/**
+* Get the version of a package from the project's package.json
+*/
+function getPackageVersion(packageName, projectDir) {
+	try {
+		const require = createRequire(import.meta.url);
+		return require(require.resolve(`${packageName}/package.json`, { paths: [projectDir] })).version;
+	} catch {
+		return "unknown";
+	}
+}
+/**
+* Logger utilities
+*/
+const colors = {
+	warn: "yellow",
+	error: "red",
+	success: "cyan",
+	info: "green",
+	debug: "gray"
+};
+const fancyLog = (level, msg) => {
+	const colorFn = chalk[colors[level]];
+	console.log(`${colorFn(level)}: ${msg}`);
+};
+const info = (msg) => fancyLog("info", msg);
+const success = (msg) => fancyLog("success", msg);
+const warn = (msg) => fancyLog("warn", msg);
+const error = (msg) => fancyLog("error", msg);
+const debug = (msg, data) => {
+	if (process.env.DEBUG || process.env.NODE_ENV !== "production") {
+		fancyLog("debug", msg);
+		if (data) console.log(data);
+	}
+};
+/**
+* Print the server information banner with URLs and versions
+*/
+function printServerInfo(mode, port, startTime, projectDir) {
+	const elapsed = Date.now() - startTime;
+	const sfnextVersion = version;
+	const reactVersion = getPackageVersion("react", projectDir);
+	const reactRouterVersion = getPackageVersion("react-router", projectDir);
+	const modeLabel = mode === "development" ? "Development Mode" : "Preview Mode";
+	console.log();
+	console.log(`  ${chalk.cyan.bold("⚡ SFCC Storefront Next")} ${chalk.dim(`v${sfnextVersion}`)}`);
+	console.log(`  ${chalk.green.bold(modeLabel)}`);
+	console.log();
+	console.log(`  ${chalk.dim("react")} ${chalk.green(`v${reactVersion}`)} ${chalk.dim("│")} ${chalk.dim("react-router")} ${chalk.green(`v${reactRouterVersion}`)} ${chalk.dim("│")} ${chalk.green(`ready in ${elapsed}ms`)}`);
+	console.log();
+}
+/**
+* Print server configuration details (proxy, static, etc.)
+*/
+function printServerConfig(config) {
+	const { port, enableProxy, enableStaticServing, enableCompression, proxyPath, proxyHost, shortCode, organizationId, clientId, siteId } = config;
+	console.log(`  ${chalk.bold("Environment Configuration:")}`);
+	if (enableProxy && proxyPath && proxyHost && shortCode) {
+		console.log(`    ${chalk.green("✓")} ${chalk.bold("Proxy:")} ${chalk.cyan(`localhost:${port}${proxyPath}`)} ${chalk.dim("→")} ${chalk.cyan(proxyHost)}`);
+		console.log(`      ${chalk.dim("Short Code:     ")} ${chalk.dim(shortCode)}`);
+		if (organizationId) console.log(`      ${chalk.dim("Organization ID:")} ${chalk.dim(organizationId)}`);
+		if (clientId) console.log(`      ${chalk.dim("Client ID:      ")} ${chalk.dim(clientId)}`);
+		if (siteId) console.log(`      ${chalk.dim("Site ID:        ")} ${chalk.dim(siteId)}`);
+	} else console.log(`    ${chalk.gray("○")} ${chalk.bold("Proxy:           ")} ${chalk.dim("disabled")}`);
+	if (enableStaticServing) console.log(`    ${chalk.green("✓")} ${chalk.bold("Static:          ")} ${chalk.dim("enabled")}`);
+	if (enableCompression) console.log(`    ${chalk.green("✓")} ${chalk.bold("Compression:     ")} ${chalk.dim("enabled")}`);
+	const localUrl = `http://localhost:${port}`;
+	const networkAddress = process.env.SHOW_NETWORK === "true" ? getNetworkAddress() : void 0;
+	const networkUrl = networkAddress ? `http://${networkAddress}:${port}` : void 0;
+	console.log();
+	console.log(`  ${chalk.green("➜")}  ${chalk.bold("Local:  ")} ${chalk.cyan(localUrl)}`);
+	if (networkUrl) console.log(`  ${chalk.green("➜")}  ${chalk.bold("Network:")} ${chalk.cyan(networkUrl)}`);
+	console.log();
+	console.log(`  ${chalk.dim("Press")} ${chalk.bold("Ctrl+C")} ${chalk.dim("to stop the server")}`);
+	console.log();
+}
+/**
+* Print shutdown message
+*/
+function printShutdownMessage() {
+	console.log(`\n  ${chalk.yellow("⚡")} ${chalk.dim("Server shutting down...")}\n`);
+}
+
+//#endregion
+export { printServerInfo as a, warn as c, printServerConfig as i, error as n, printShutdownMessage as o, info as r, success as s, debug as t };

package/dist/manage-extensions.js

@@ -0,0 +1,329 @@
+import { a as trimExtensions, r as resolveDependentsForMultiple, t as getMissingDependencies } from "./dependency-utils.js";
+import { execSync } from "child_process";
+import os from "os";
+import path from "path";
+import fs from "fs-extra";
+import prompts from "prompts";
+import { z } from "zod";
+
+//#region src/extensibility/manage-extensions.ts
+const EXTENSIONS_DIR = ["src", "extensions"];
+const CONFIG_PATH = [...EXTENSIONS_DIR, "config.json"];
+const EXTENSION_FOLDERS = [
+	"components",
+	"locales",
+	"hooks",
+	"routes"
+];
+/**
+* Console log a message with a specific type
+* @param message string
+* @param type
+*/
+const consoleLog = (message, type) => {
+	switch (type) {
+		case "error":
+			console.error(`❌ ${message}`);
+			break;
+		case "success":
+			console.log(`✅ ${message}`);
+			break;
+		default:
+			console.log(message);
+			break;
+	}
+};
+/**
+* Get the path to the extension config file
+*/
+const getExtensionConfigPath = (projectDirectory) => {
+	return path.join(projectDirectory, ...CONFIG_PATH);
+};
+/**
+* Check if the project directory contains the extensions directory and config.json file
+*/
+const getExtensionConfig = (projectDirectory) => {
+	const extensionConfigPath = getExtensionConfigPath(projectDirectory);
+	if (!fs.existsSync(extensionConfigPath)) {
+		consoleLog(`Extension config file not found: ${extensionConfigPath}. Are you running this command in the correct project directory?`, "error");
+		process.exit(1);
+	}
+	return JSON.parse(fs.readFileSync(extensionConfigPath, "utf8")).extensions;
+};
+/**
+* Common function to get the extension selection from the user
+* @param type 'multiselect' | 'select'
+* @param extensionConfig Record<string, ExtensionMeta>
+* @param message string
+* @param installedExtensions string[]
+* @param excludeExtensions string[] extensions to exclude from the list, so we can filter out extensions that are already installed
+* @returns string[]
+*/
+const getExtensionSelection = async (type, extensionConfig, message, installedExtensions, excludeExtensions = []) => {
+	consoleLog("\n", "info");
+	const { selectedExtensions } = await prompts({
+		type,
+		name: "selectedExtensions",
+		message,
+		choices: installedExtensions.filter((extensionKey) => !excludeExtensions.includes(extensionKey)).map((extensionKey) => ({
+			title: `${extensionConfig[extensionKey].name} - ${extensionConfig[extensionKey].description}`,
+			value: extensionKey
+		})),
+		instructions: false
+	});
+	return type === "multiselect" ? selectedExtensions : [selectedExtensions];
+};
+/**
+* Handle the uninstallation of extensions
+* @param extensionConfig Record<string, ExtensionMeta>
+* @param options {
+projectDirectory: string;
+extensions?: string[];
+verbose?: boolean;
+}
+* @returns void
+*/
+const handleUninstall = async (extensionConfig, options) => {
+	let installedExtensions = Object.keys(extensionConfig);
+	if (installedExtensions.length === 0) {
+		consoleLog("\n You have not installed any extensions yet.", "error");
+		return;
+	}
+	const selectedExtensions = options.extensions ? options.extensions : await getExtensionSelection("multiselect", extensionConfig, "🔌 Which extensions would you like to uninstall?", installedExtensions);
+	if (selectedExtensions == null || selectedExtensions.length === 0) {
+		consoleLog("\n Please select at least one extension to uninstall.", "error");
+		return;
+	}
+	const allToUninstall = resolveDependentsForMultiple(selectedExtensions, { extensions: extensionConfig });
+	const installedSet = new Set(installedExtensions);
+	const extensionsToUninstall = allToUninstall.filter((key) => installedSet.has(key));
+	const selectedSet = new Set(selectedExtensions);
+	const additionalDependents = extensionsToUninstall.filter((key) => !selectedSet.has(key));
+	if (additionalDependents.length > 0) {
+		consoleLog("\n", "info");
+		consoleLog(`Uninstalling the selected extension(s) will also uninstall the following dependent extensions:`, "info");
+		additionalDependents.forEach((depKey) => {
+			const depExtension = extensionConfig[depKey];
+			const dependsOn = selectedExtensions.find((selKey) => {
+				return extensionConfig[selKey] && extensionConfig[depKey]?.dependencies?.includes(selKey);
+			});
+			const dependsOnName = dependsOn ? extensionConfig[dependsOn]?.name : "selected extension";
+			consoleLog(` • ${depExtension?.name || depKey} (depends on ${dependsOnName})`, "info");
+		});
+		consoleLog("\n", "info");
+		const { confirmUninstall } = await prompts({
+			type: "confirm",
+			name: "confirmUninstall",
+			message: `Uninstall all ${extensionsToUninstall.length} extensions?`,
+			initial: true
+		});
+		if (!confirmUninstall) {
+			consoleLog("Uninstallation aborted.", "info");
+			return;
+		}
+	}
+	extensionsToUninstall.forEach((ext) => {
+		if (extensionConfig[ext]?.folder) fs.rmSync(path.join(options.projectDirectory, ...EXTENSIONS_DIR, extensionConfig[ext].folder), {
+			recursive: true,
+			force: true
+		});
+	});
+	const extensionsToUninstallSet = new Set(extensionsToUninstall);
+	installedExtensions = installedExtensions.filter((ext) => !extensionsToUninstallSet.has(ext));
+	trimExtensions(options.projectDirectory, Object.fromEntries(installedExtensions.map((ext) => [ext, true])), { extensions: extensionConfig }, options.verbose ?? false);
+	consoleLog(" Extensions uninstalled.", "success");
+};
+/**
+* Install a single extension (internal helper)
+* @returns true if installation succeeded, false otherwise
+*/
+const installSingleExtension = (extensionKey, srcExtensionConfig, extensionConfig, tmpDir, projectDirectory) => {
+	const extension = srcExtensionConfig[extensionKey];
+	const startTime = Date.now();
+	if (extension.folder) fs.copySync(path.join(tmpDir, ...EXTENSIONS_DIR, extension.folder), path.join(projectDirectory, ...EXTENSIONS_DIR, extension.folder));
+	if (extension.installationInstructions) {
+		console.log(`\n⏳ Installing ${extension.name}, this will take a few minutes...`);
+		try {
+			execSync(`cursor-agent -p --force 'Execute the steps specified in the installation instructions file: ${extension.installationInstructions}' --output-format text`, {
+				cwd: projectDirectory,
+				stdio: "inherit"
+			});
+		} catch (e) {
+			consoleLog(`Error installing ${extension.name}. ${e.message}`, "error");
+			return false;
+		}
+	}
+	extensionConfig[extensionKey] = extension;
+	fs.writeFileSync(getExtensionConfigPath(projectDirectory), JSON.stringify({ extensions: extensionConfig }, null, 4));
+	consoleLog(`${extension.name} was installed successfully. (${Date.now() - startTime}ms)`, "success");
+	return true;
+};
+/**
+* Handle the installation of extensions
+* @param extensionConfig
+* @param options {
+sourceGithubUrl?: string;
+projectDirectory: string;
+extensions?: string[];
+verbose?: boolean;
+}
+* @returns
+*/
+const handleInstall = async (extensionConfig, options) => {
+	const { sourceGitUrl } = await prompts({
+		type: "text",
+		name: "sourceGitUrl",
+		message: "🌐 What is the Git URL for the extensions project?",
+		initial: options.sourceGitUrl
+	});
+	const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), `sfnext-extensions-${Date.now()}`));
+	execSync(`git clone ${sourceGitUrl} ${tmpDir}`);
+	const srcExtensionConfig = getExtensionConfig(tmpDir);
+	if (srcExtensionConfig == null || Object.keys(srcExtensionConfig).length === 0) {
+		consoleLog(`No extensions found in the source project, please check ${path.join(...CONFIG_PATH)} exists in ${sourceGitUrl} and contains at least one extension.`, "error");
+		return;
+	}
+	const selectedExtensions = options.extensions ? options.extensions : await getExtensionSelection("select", srcExtensionConfig, "🔌 Which extension would you like to install?", Object.keys(srcExtensionConfig), Object.keys(extensionConfig));
+	if (selectedExtensions == null || selectedExtensions.length !== 1 || selectedExtensions[0] == null) {
+		consoleLog("Please select exactly one extension to install.", "error");
+		return;
+	}
+	const extensionKey = selectedExtensions[0];
+	const extension = srcExtensionConfig[extensionKey];
+	if (Object.values(srcExtensionConfig).some((ext) => ext.installationInstructions)) try {
+		execSync("cursor-agent -v", { stdio: "ignore" });
+	} catch (e) {
+		consoleLog("This extension contains LLM instructions, please install cursor cli and try again. (https://cursor.com/docs/cli/overview)", "error");
+		return;
+	}
+	const srcConfig = { extensions: srcExtensionConfig };
+	const missingDeps = getMissingDependencies(extensionKey, Object.keys(extensionConfig), srcConfig);
+	const dependenciesToInstall = missingDeps.slice(0, -1);
+	let hasError = false;
+	try {
+		if (dependenciesToInstall.length > 0) {
+			consoleLog("\n", "info");
+			consoleLog(`Installing ${extension.name} requires the following dependencies:`, "info");
+			dependenciesToInstall.forEach((depKey) => {
+				const depExtension = srcExtensionConfig[depKey];
+				consoleLog(` • ${depExtension?.name || depKey} (not installed)`, "info");
+			});
+			consoleLog("\n", "info");
+			const estimatedMinutes = missingDeps.length * 5;
+			const { confirmInstall } = await prompts({
+				type: "confirm",
+				name: "confirmInstall",
+				message: `Install all ${missingDeps.length} extensions? (~${estimatedMinutes} minutes total)`,
+				initial: true
+			});
+			if (!confirmInstall) {
+				consoleLog("Installation aborted.", "info");
+				return;
+			}
+		}
+		for (const depKey of missingDeps) if (!installSingleExtension(depKey, srcExtensionConfig, extensionConfig, tmpDir, options.projectDirectory)) hasError = true;
+	} finally {
+		fs.rmSync(tmpDir, {
+			recursive: true,
+			force: true
+		});
+	}
+	const originalFiles = fs.readdirSync(path.join(options.projectDirectory, "src"), { recursive: true }).filter((file) => file.toString().endsWith(".original"));
+	if (originalFiles.length > 0) {
+		consoleLog("\n📄 The following files were modified. The original files are still available in the same location with the \".original\" extension.:", "info");
+		originalFiles.forEach((file) => {
+			consoleLog(`- ${file.toString().replace(".original", "")}`, "info");
+		});
+	}
+	if (!hasError) consoleLog("\n🚀 Installation completed successfully.", "info");
+};
+const manageExtensions = async (options) => {
+	if (options.install && options.uninstall) {
+		consoleLog("Please select either install or uninstall, not both.", "error");
+		return;
+	}
+	let operation = options.install ? "install" : options.uninstall ? "uninstall" : void 0;
+	const extensionConfig = getExtensionConfig(options.projectDirectory);
+	if (operation == null) operation = (await prompts({
+		type: "select",
+		name: "operation",
+		message: "🤔 What would you like to do?",
+		choices: [{
+			title: "Install extensions",
+			value: "install"
+		}, {
+			title: "Uninstall extensions",
+			value: "uninstall"
+		}]
+	})).operation;
+	if (operation === "uninstall") await handleUninstall(extensionConfig, options);
+	else await handleInstall(extensionConfig, options);
+};
+const getExtensionMarker = (val) => {
+	return `SFDC_EXT_${val.toUpperCase().replaceAll(" ", "_").replaceAll("-", "_")}`;
+};
+const getExtensionFolderName = (val) => {
+	return val.toLowerCase().replaceAll(" ", "-").trim();
+};
+const getExtensionNameSchema = (projectDirectory, extensionConfig) => {
+	return z.object({ name: z.string().regex(/^[a-zA-Z0-9 _-]+$/, { message: "Extension name can only contain alphanumeric characters, spaces, dashes, or underscores" }) }).superRefine((data, ctx) => {
+		if (extensionConfig[getExtensionMarker(data.name)]) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: `Extension "${data.name}" already exists`
+		});
+		if (fs.existsSync(path.join(projectDirectory, ...EXTENSIONS_DIR, getExtensionFolderName(data.name)))) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: `Extension directory ${getExtensionFolderName(data.name)} already exists`
+		});
+	});
+};
+const listExtensions = (options) => {
+	const extensionConfig = getExtensionConfig(options.projectDirectory);
+	consoleLog("The following extensions are installed:", "info");
+	Object.keys(extensionConfig).forEach((key) => {
+		consoleLog(`- ${extensionConfig[key].name}: ${extensionConfig[key].description}`, "info");
+	});
+};
+const createExtension = async (options) => {
+	const { projectDirectory, name, description } = options;
+	const extensionConfig = getExtensionConfig(projectDirectory);
+	let extensionName = name;
+	let extensionDescription = description;
+	if (extensionName == null || extensionName.trim() === "") extensionName = (await prompts({
+		type: "text",
+		name: "extensionName",
+		message: "What would you like to name the extension? (e.g., \"My Extension\")"
+	})).extensionName;
+	const result = getExtensionNameSchema(projectDirectory, extensionConfig).safeParse({ name: extensionName });
+	if (!result.success) {
+		const firstIssueMessage = result.error.issues?.[0]?.message;
+		consoleLog(firstIssueMessage, "error");
+		return;
+	}
+	if (extensionDescription == null || extensionDescription.trim() === "") extensionDescription = (await prompts({
+		type: "text",
+		name: "extensionDescription",
+		message: "How would you describe the extension?"
+	})).extensionDescription;
+	const folderName = getExtensionFolderName(extensionName);
+	const extensionFolderPath = path.join(projectDirectory, ...EXTENSIONS_DIR, folderName);
+	fs.mkdirSync(extensionFolderPath, { recursive: true });
+	EXTENSION_FOLDERS.forEach((folder) => {
+		fs.mkdirSync(path.join(extensionFolderPath, folder), { recursive: true });
+	});
+	fs.writeFileSync(path.join(extensionFolderPath, "README.md"), `# ${extensionName}\n\n${extensionDescription}`);
+	const marker = getExtensionMarker(extensionName);
+	extensionConfig[marker] = {
+		name: extensionName,
+		description: extensionDescription,
+		installationInstructions: "",
+		uninstallationInstructions: "",
+		folder: folderName,
+		dependencies: []
+	};
+	fs.writeFileSync(path.join(projectDirectory, ...CONFIG_PATH), JSON.stringify({ extensions: extensionConfig }, null, 4));
+	consoleLog(`Extension "${extensionName}" scaffolding was created successfully.`, "success");
+};
+
+//#endregion
+export { listExtensions as n, manageExtensions as r, createExtension as t };