@gxp-dev/tools 2.0.5

package/bin/lib/utils/files.js

@@ -0,0 +1,180 @@
+/**
+ * File Utilities
+ *
+ * Handles file operations like safe copying and package.json management.
+ */
+
+const path = require("path");
+const fs = require("fs");
+const shell = require("shelljs");
+const {
+	REQUIRED_DEPENDENCIES,
+	REQUIRED_DEV_DEPENDENCIES,
+	DEFAULT_SCRIPTS,
+} = require("../constants");
+const { loadGlobalConfig } = require("./paths");
+
+/**
+ * Copies a file from source to destination, creating directories if needed
+ */
+function safeCopyFile(src, dest, description) {
+	if (!fs.existsSync(dest)) {
+		console.log(`Creating ${description}`);
+		const destDir = path.dirname(dest);
+		if (!fs.existsSync(destDir)) {
+			fs.mkdirSync(destDir, { recursive: true });
+		}
+		fs.copyFileSync(src, dest);
+	}
+}
+
+/**
+ * Creates package.json for new projects
+ */
+function createPackageJson(projectPath, projectName) {
+	const packageJsonPath = path.join(projectPath, "package.json");
+	const globalConfig = loadGlobalConfig();
+
+	const packageJson = {
+		name: projectName,
+		version: "1.0.0",
+		description: `GxP Plugin: ${projectName}`,
+		main: "main.js",
+		scripts: {
+			...DEFAULT_SCRIPTS,
+			placeholder:
+				"gxdev assets generate --size 400x300 --name custom-placeholder",
+		},
+		dependencies: REQUIRED_DEPENDENCIES,
+		devDependencies: REQUIRED_DEV_DEPENDENCIES,
+		author: globalConfig.author || "Your Name",
+		license: "ISC",
+	};
+
+	fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+	console.log("✓ Created package.json");
+}
+
+/**
+ * Installs npm dependencies
+ */
+function installDependencies(projectPath) {
+	console.log("\n📦 Installing dependencies...");
+	const currentDir = process.cwd();
+
+	try {
+		process.chdir(projectPath);
+		const result = shell.exec("npm install", { silent: false });
+		if (result.code !== 0) {
+			console.warn("⚠ npm install completed with warnings");
+		}
+	} finally {
+		process.chdir(currentDir);
+	}
+}
+
+/**
+ * Updates existing project's package.json with missing dependencies and scripts
+ */
+function updateExistingProject(projectPath) {
+	const packageJsonPath = path.join(projectPath, "package.json");
+
+	if (!fs.existsSync(packageJsonPath)) {
+		return false;
+	}
+
+	try {
+		const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+		let updated = false;
+
+		// Check and add missing dependencies
+		if (!packageJson.dependencies) {
+			packageJson.dependencies = {};
+		}
+
+		for (const [dep, version] of Object.entries(REQUIRED_DEPENDENCIES)) {
+			if (!packageJson.dependencies[dep]) {
+				packageJson.dependencies[dep] = version;
+				console.log(`  + Adding dependency: ${dep}@${version}`);
+				updated = true;
+			}
+		}
+
+		// Check and add missing dev dependencies
+		if (!packageJson.devDependencies) {
+			packageJson.devDependencies = {};
+		}
+
+		for (const [dep, version] of Object.entries(REQUIRED_DEV_DEPENDENCIES)) {
+			if (!packageJson.devDependencies[dep]) {
+				packageJson.devDependencies[dep] = version;
+				console.log(`  + Adding devDependency: ${dep}@${version}`);
+				updated = true;
+			}
+		}
+
+		// Check and add missing scripts
+		if (!packageJson.scripts) {
+			packageJson.scripts = {};
+		}
+
+		for (const [script, command] of Object.entries(DEFAULT_SCRIPTS)) {
+			if (!packageJson.scripts[script]) {
+				packageJson.scripts[script] = command;
+				console.log(`  + Adding script: ${script}`);
+				updated = true;
+			}
+		}
+
+		if (updated) {
+			fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+			console.log("✓ Updated package.json");
+			return true;
+		}
+
+		return false;
+	} catch (error) {
+		console.error("Error updating package.json:", error.message);
+		return false;
+	}
+}
+
+/**
+ * Checks if ImageMagick is available globally
+ */
+function isImageMagickInstalled() {
+	return shell.which("magick") !== null || shell.which("convert") !== null;
+}
+
+/**
+ * Ensures ImageMagick is available for placeholder generation
+ */
+function ensureImageMagickInstalled() {
+	if (isImageMagickInstalled()) {
+		console.log("✓ ImageMagick is available");
+		return true;
+	}
+
+	console.log("⚠️  ImageMagick not found");
+	console.log("📦 ImageMagick is required for generating placeholder images");
+	console.log("");
+	console.log("🍎 macOS: brew install imagemagick");
+	console.log("🐧 Ubuntu/Debian: sudo apt-get install imagemagick");
+	console.log(
+		"🟦 Windows: Download from https://imagemagick.org/script/download.php#windows"
+	);
+	console.log("");
+	console.log("💡 After installation, you can generate placeholders with:");
+	console.log("   gxdev assets generate --size 400x300 --name my-placeholder");
+	console.log("   gxdev assets generate --name icons --count 3 --size 64x64");
+	return false;
+}
+
+module.exports = {
+	safeCopyFile,
+	createPackageJson,
+	installDependencies,
+	updateExistingProject,
+	isImageMagickInstalled,
+	ensureImageMagickInstalled,
+};

package/bin/lib/utils/index.js

@@ -0,0 +1,17 @@
+/**
+ * Utility Functions Index
+ *
+ * Re-exports all utility modules for convenient importing.
+ */
+
+const paths = require("./paths");
+const ssl = require("./ssl");
+const files = require("./files");
+const prompts = require("./prompts");
+
+module.exports = {
+	...paths,
+	...ssl,
+	...files,
+	...prompts,
+};

package/bin/lib/utils/paths.js

@@ -0,0 +1,138 @@
+/**
+ * Path Resolution Utilities
+ *
+ * Handles finding project roots and resolving paths to toolkit resources.
+ */
+
+const path = require("path");
+const fs = require("fs");
+const os = require("os");
+const { isWin, PACKAGE_NAME } = require("../constants");
+
+/**
+ * Determines the correct binary name based on platform and architecture
+ */
+function getBinaryName() {
+	if (isWin) return "gento-win";
+	if (process.arch === "x64") return "gento-darwin-amd64";
+	return "gento";
+}
+
+/**
+ * Finds the project root directory by looking for package.json
+ */
+function findProjectRoot() {
+	let currentDir = process.cwd();
+
+	while (currentDir !== path.dirname(currentDir)) {
+		if (fs.existsSync(path.join(currentDir, "package.json"))) {
+			return currentDir;
+		}
+		currentDir = path.dirname(currentDir);
+	}
+
+	return process.cwd(); // Fallback to current directory
+}
+
+/**
+ * Resolves paths for gx-devtools resources based on installation context
+ *
+ * Directory structure:
+ * - /template/     - Files copied to new projects during init
+ * - /runtime/      - Files used from node_modules (not copied to projects)
+ * - /socket-events/ - Socket event templates
+ */
+function resolveGxPaths() {
+	const projectRoot = findProjectRoot();
+
+	// Try local installation first
+	const localNodeModules = path.join(projectRoot, "node_modules", PACKAGE_NAME);
+	if (fs.existsSync(localNodeModules)) {
+		return {
+			gentoPath: path.join(localNodeModules, "bin", getBinaryName()),
+			viteConfigPath: path.join(localNodeModules, "runtime", "vite.config.js"),
+			templateDir: path.join(localNodeModules, "template"),
+			runtimeDir: path.join(localNodeModules, "runtime"),
+			socketEventsDir: path.join(localNodeModules, "socket-events"),
+			packageRoot: localNodeModules,
+			// Legacy alias for backward compatibility
+			configDir: path.join(localNodeModules, "template"),
+		};
+	}
+
+	// Try global installation (or running from the toolkit itself)
+	const globalNodeModules = path.join(__dirname, "..", "..", "..");
+	return {
+		gentoPath: path.join(globalNodeModules, "bin", getBinaryName()),
+		viteConfigPath: path.join(globalNodeModules, "runtime", "vite.config.js"),
+		templateDir: path.join(globalNodeModules, "template"),
+		runtimeDir: path.join(globalNodeModules, "runtime"),
+		socketEventsDir: path.join(globalNodeModules, "socket-events"),
+		packageRoot: globalNodeModules,
+		// Legacy alias for backward compatibility
+		configDir: path.join(globalNodeModules, "template"),
+	};
+}
+
+/**
+ * Resolves file path checking local project first, then package
+ *
+ * @param {string} fileName - The file to find
+ * @param {string} subDir - Subdirectory within the search locations
+ * @param {string} packageLocation - Which package directory to check: 'template', 'runtime', or 'socket-events'
+ */
+function resolveFilePath(fileName, subDir = "", packageLocation = "template") {
+	const projectRoot = findProjectRoot();
+	const paths = resolveGxPaths();
+
+	// Check local project first
+	const localPath = path.join(projectRoot, subDir, fileName);
+	if (fs.existsSync(localPath)) {
+		return { path: localPath, isLocal: true };
+	}
+
+	// Determine which package directory to check
+	let packageDir;
+	switch (packageLocation) {
+		case "runtime":
+			packageDir = paths.runtimeDir;
+			break;
+		case "socket-events":
+			packageDir = paths.socketEventsDir;
+			break;
+		default:
+			packageDir = paths.templateDir;
+	}
+
+	// Fall back to package version
+	const packagePath = path.join(packageDir, subDir, fileName);
+	if (fs.existsSync(packagePath)) {
+		return { path: packagePath, isLocal: false };
+	}
+
+	// Return package path even if doesn't exist (for error handling)
+	return { path: packagePath, isLocal: false };
+}
+
+/**
+ * Loads global configuration if available
+ */
+function loadGlobalConfig() {
+	const globalConfigPath = path.join(os.homedir(), "gxdev-default-config.json");
+	if (fs.existsSync(globalConfigPath)) {
+		try {
+			return JSON.parse(fs.readFileSync(globalConfigPath, "utf-8"));
+		} catch (error) {
+			console.warn("Warning: Could not parse global configuration");
+		}
+	}
+	return {};
+}
+
+module.exports = {
+	getBinaryName,
+	findProjectRoot,
+	resolveGxPaths,
+	resolveFilePath,
+	loadGlobalConfig,
+};

package/bin/lib/utils/prompts.js

@@ -0,0 +1,71 @@
+/**
+ * User Prompts Utility
+ *
+ * Handles interactive CLI prompts.
+ */
+
+const readline = require("readline");
+
+/**
+ * Prompts user for input
+ * @param {string} question - The question to ask
+ * @returns {Promise<string>} The user's answer
+ */
+function promptUser(question) {
+	const rl = readline.createInterface({
+		input: process.stdin,
+		output: process.stdout,
+	});
+
+	return new Promise((resolve) => {
+		rl.question(question, (answer) => {
+			rl.close();
+			resolve(answer);
+		});
+	});
+}
+
+/**
+ * Prompts user for yes/no confirmation
+ * @param {string} question - The question to ask
+ * @param {boolean} defaultYes - Whether default is yes (Y/n) or no (y/N)
+ * @returns {Promise<boolean>} True if user confirmed
+ */
+async function confirmPrompt(question, defaultYes = true) {
+	const suffix = defaultYes ? "(Y/n)" : "(y/N)";
+	const answer = await promptUser(`${question} ${suffix}: `);
+
+	if (answer === "") {
+		return defaultYes;
+	}
+
+	return answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
+}
+
+/**
+ * Prompts user to select from a list of options
+ * @param {string} question - The question to ask
+ * @param {string[]} options - Array of options
+ * @returns {Promise<number>} Index of selected option
+ */
+async function selectPrompt(question, options) {
+	console.log(question);
+	options.forEach((opt, i) => {
+		console.log(`  ${i + 1}. ${opt}`);
+	});
+
+	const answer = await promptUser("Enter number: ");
+	const index = parseInt(answer, 10) - 1;
+
+	if (index >= 0 && index < options.length) {
+		return index;
+	}
+
+	return 0; // Default to first option
+}
+
+module.exports = {
+	promptUser,
+	confirmPrompt,
+	selectPrompt,
+};

package/bin/lib/utils/ssl.js

@@ -0,0 +1,233 @@
+/**
+ * SSL Certificate Management
+ *
+ * Handles SSL certificate generation and management using mkcert.
+ */
+
+const path = require("path");
+const fs = require("fs");
+const shell = require("shelljs");
+
+/**
+ * Checks if mkcert is installed globally
+ */
+function isMkcertInstalled() {
+	return shell.which("mkcert") !== null;
+}
+
+/**
+ * Installs mkcert globally if not already installed
+ */
+function ensureMkcertInstalled() {
+	if (isMkcertInstalled()) {
+		console.log("✓ mkcert is already installed globally");
+		return true;
+	}
+
+	console.log("Installing mkcert globally...");
+	const result = shell.exec("npm install -g mkcert", { silent: true });
+
+	if (result.code === 0) {
+		console.log("✓ mkcert installed successfully");
+		return true;
+	} else {
+		console.warn("⚠ Could not install mkcert globally, will use local version");
+		return false;
+	}
+}
+
+/**
+ * Finds existing SSL certificates in the certs directory, including those with suffixes
+ */
+function findExistingCertificates(certsDir) {
+	if (!fs.existsSync(certsDir)) {
+		return null;
+	}
+
+	const files = fs.readdirSync(certsDir);
+
+	// Look for localhost certificates (with or without suffixes)
+	const certFile = files.find(
+		(f) =>
+			f.startsWith("localhost") && f.endsWith(".pem") && !f.includes("-key")
+	);
+	const keyFile = files.find(
+		(f) => f.startsWith("localhost") && f.endsWith("-key.pem")
+	);
+
+	if (certFile && keyFile) {
+		const certPath = path.join(certsDir, certFile);
+		const keyPath = path.join(certsDir, keyFile);
+
+		// Verify files actually exist and have content
+		try {
+			const certStats = fs.statSync(certPath);
+			const keyStats = fs.statSync(keyPath);
+
+			if (certStats.size > 0 && keyStats.size > 0) {
+				return { certPath, keyPath };
+			}
+		} catch (error) {
+			// Files don't exist or can't be read
+		}
+	}
+
+	return null;
+}
+
+/**
+ * Cleans up old SSL certificate files to prevent naming conflicts
+ */
+function cleanupOldCertificates(certsDir) {
+	if (!fs.existsSync(certsDir)) {
+		return;
+	}
+
+	try {
+		const files = fs.readdirSync(certsDir);
+		const certFiles = files.filter(
+			(f) =>
+				f.startsWith("localhost") &&
+				(f.endsWith(".pem") || f.endsWith("-key.pem"))
+		);
+
+		if (certFiles.length > 0) {
+			console.log("🧹 Cleaning up old certificate files...");
+			certFiles.forEach((file) => {
+				const filePath = path.join(certsDir, file);
+				try {
+					fs.unlinkSync(filePath);
+					console.log(`   Removed: ${file}`);
+				} catch (error) {
+					console.warn(`   Could not remove ${file}: ${error.message}`);
+				}
+			});
+		}
+	} catch (error) {
+		console.warn("⚠ Could not clean up old certificates:", error.message);
+	}
+}
+
+/**
+ * Generates SSL certificates for localhost using mkcert
+ */
+function generateSSLCertificates(projectPath) {
+	const certsDir = path.join(projectPath, ".certs");
+
+	// Create .certs directory
+	if (!fs.existsSync(certsDir)) {
+		fs.mkdirSync(certsDir, { recursive: true });
+	}
+
+	// Check for existing certificates (including those with suffixes like +2)
+	const existingCerts = findExistingCertificates(certsDir);
+	if (existingCerts) {
+		console.log("✓ SSL certificates already exist");
+		return existingCerts;
+	}
+
+	console.log("Generating SSL certificates for localhost...");
+
+	// Clean up any leftover certificate files to avoid naming conflicts
+	cleanupOldCertificates(certsDir);
+
+	// Try global mkcert first
+	let mkcertCmd = "mkcert";
+	if (!isMkcertInstalled()) {
+		// Use local mkcert via npx
+		mkcertCmd = "npx mkcert";
+	}
+
+	// Change to certs directory and generate certificates
+	const currentDir = process.cwd();
+	try {
+		process.chdir(certsDir);
+
+		// Install CA if needed (only for global mkcert)
+		if (isMkcertInstalled()) {
+			shell.exec(`${mkcertCmd} -install`, { silent: true });
+		}
+
+		// Generate certificates for localhost
+		const result = shell.exec(`${mkcertCmd} localhost 127.0.0.1 ::1`, {
+			silent: true,
+		});
+
+		if (result.code === 0) {
+			// Find the actual generated certificate files
+			const generatedCerts = findExistingCertificates(certsDir);
+			if (generatedCerts) {
+				console.log("✓ SSL certificates generated successfully");
+				console.log(
+					`📁 Certificate: ${path.basename(generatedCerts.certPath)}`
+				);
+				console.log(`🔑 Key: ${path.basename(generatedCerts.keyPath)}`);
+				return generatedCerts;
+			} else {
+				console.warn(
+					"⚠ Certificates generated but not found in expected location"
+				);
+				return null;
+			}
+		} else {
+			console.warn(
+				"⚠ Failed to generate SSL certificates, falling back to HTTP"
+			);
+			return null;
+		}
+	} catch (error) {
+		console.warn("⚠ Error generating SSL certificates:", error.message);
+		return null;
+	} finally {
+		process.chdir(currentDir);
+	}
+}
+
+/**
+ * Updates the .env file with the actual SSL certificate paths
+ */
+function updateEnvWithCertPaths(projectPath, certs) {
+	const envPath = path.join(projectPath, ".env");
+
+	if (!fs.existsSync(envPath)) {
+		console.warn("⚠ .env file not found, skipping certificate path update");
+		return;
+	}
+
+	try {
+		let envContent = fs.readFileSync(envPath, "utf-8");
+
+		// Get just the filenames from the full paths
+		const certFileName = path.basename(certs.certPath);
+		const keyFileName = path.basename(certs.keyPath);
+
+		// Update CERT_PATH and KEY_PATH with actual filenames
+		envContent = envContent.replace(
+			/CERT_PATH=.*$/m,
+			`CERT_PATH=.certs/${certFileName}`
+		);
+		envContent = envContent.replace(
+			/KEY_PATH=.*$/m,
+			`KEY_PATH=.certs/${keyFileName}`
+		);
+
+		fs.writeFileSync(envPath, envContent);
+		console.log("✓ Updated .env with SSL certificate paths");
+		console.log(`   CERT_PATH=.certs/${certFileName}`);
+		console.log(`   KEY_PATH=.certs/${keyFileName}`);
+	} catch (error) {
+		console.warn(
+			"⚠ Could not update .env with certificate paths:",
+			error.message
+		);
+	}
+}
+
+module.exports = {
+	isMkcertInstalled,
+	ensureMkcertInstalled,
+	findExistingCertificates,
+	cleanupOldCertificates,
+	generateSSLCertificates,
+	updateEnvWithCertPaths,
+};

package/browser-extensions/README.md

@@ -0,0 +1 @@
+