@gxp-dev/tools 2.0.5

package/bin/lib/commands/dev.js

@@ -0,0 +1,328 @@
+/**
+ * Dev Command
+ *
+ * Starts the development server with optional Socket.IO support
+ * and browser extension launching.
+ */
+
+const path = require("path");
+const fs = require("fs");
+const shell = require("shelljs");
+const dotenv = require("dotenv");
+const { exportCmd } = require("../constants");
+const {
+	findProjectRoot,
+	resolveGxPaths,
+	resolveFilePath,
+	findExistingCertificates,
+} = require("../utils");
+
+/**
+ * Get browser extension paths and commands
+ * @param {string} browser - "firefox" or "chrome"
+ * @param {string} projectPath - Project root path
+ * @param {Object} paths - Resolved GxP paths
+ * @param {Object} options - Additional options
+ * @param {boolean} options.useHttps - Whether HTTPS is enabled
+ * @param {number|string} options.port - Dev server port
+ */
+function getBrowserExtensionConfig(browser, projectPath, paths, options = {}) {
+	const { useHttps = true, port = 3060 } = options;
+	const protocol = useHttps ? "https" : "http";
+	const startUrl = `${protocol}://localhost:${port}`;
+
+	if (browser === "firefox") {
+		let extensionPath = path.join(projectPath, "browser-extensions", "firefox");
+
+		if (!fs.existsSync(extensionPath)) {
+			const toolkitExtensionPath = path.join(
+				paths.packageRoot,
+				"browser-extensions",
+				"firefox"
+			);
+			if (fs.existsSync(toolkitExtensionPath)) {
+				extensionPath = toolkitExtensionPath;
+			} else {
+				return null;
+			}
+		}
+
+		return {
+			name: "FIREFOX",
+			color: "yellow",
+			command: `npx web-ext run --source-dir "${extensionPath}" --start-url "${startUrl}"`,
+			extensionPath,
+			startUrl,
+		};
+	}
+
+	if (browser === "chrome") {
+		let extensionPath = path.join(projectPath, "browser-extensions", "chrome");
+		let scriptPath = path.join(projectPath, "scripts", "launch-chrome.js");
+
+		if (!fs.existsSync(extensionPath)) {
+			const toolkitExtensionPath = path.join(
+				paths.packageRoot,
+				"browser-extensions",
+				"chrome"
+			);
+			if (fs.existsSync(toolkitExtensionPath)) {
+				extensionPath = toolkitExtensionPath;
+				scriptPath = path.join(
+					paths.packageRoot,
+					"scripts",
+					"launch-chrome.js"
+				);
+			} else {
+				return null;
+			}
+		}
+
+		if (!fs.existsSync(scriptPath)) {
+			return null;
+		}
+
+		return {
+			name: "CHROME",
+			color: "blue",
+			command: `CHROME_EXTENSION_PATH="${extensionPath}" USE_HTTPS="${useHttps}" NODE_PORT="${port}" node "${scriptPath}"`,
+			extensionPath,
+			startUrl,
+		};
+	}
+
+	return null;
+}
+
+/**
+ * Development command - starts the dev server
+ */
+function devCommand(argv) {
+	const paths = resolveGxPaths();
+	const projectPath = findProjectRoot();
+
+	// Load .env file if it exists for default values
+	const envPath = path.join(projectPath, ".env");
+	const envExamplePath = path.join(projectPath, ".env.example");
+
+	// Load .env file into process.env
+	if (fs.existsSync(envPath)) {
+		console.log("📋 Loading environment variables from .env file");
+		dotenv.config({ path: envPath });
+	} else if (fs.existsSync(envExamplePath)) {
+		console.log(
+			"💡 Tip: Create .env file from .env.example to customize your environment settings"
+		);
+		console.log("   cp .env.example .env");
+	}
+
+	// Check for SSL certificates unless explicitly disabled
+	let useHttps = !argv["no-https"];
+	let certPath = "";
+	let keyPath = "";
+
+	if (useHttps) {
+		const certsDir = path.join(projectPath, ".certs");
+		const existingCerts = findExistingCertificates(certsDir);
+
+		if (!existingCerts) {
+			console.log(
+				"⚠ SSL certificates not found. Run 'npm run setup-ssl' to enable HTTPS"
+			);
+			console.log("🌐 Starting HTTP development server...");
+			useHttps = false;
+		} else {
+			console.log("🔒 Starting HTTPS development server...");
+			console.log(
+				`📁 Using certificate: ${path.basename(existingCerts.certPath)}`
+			);
+			console.log(`🔑 Using key: ${path.basename(existingCerts.keyPath)}`);
+			certPath = existingCerts.certPath;
+			keyPath = existingCerts.keyPath;
+		}
+	} else {
+		console.log("🌐 Starting HTTP development server...");
+	}
+
+	// Determine final port value (priority: CLI arg > .env > default)
+	const finalPort = argv.port || process.env.NODE_PORT || 3000;
+	console.log(`🌐 Development server will start on port: ${finalPort}`);
+
+	// Check if mock API should be enabled
+	const withMock = argv["with-mock"];
+	if (withMock) {
+		console.log("🎭 Mock API will be enabled");
+	}
+
+	// Check if socket server should be started
+	const withSocket = argv["with-socket"];
+	let serverJsPath = "";
+	if (withSocket) {
+		// Check for local server.js first, then runtime directory
+		const serverJs = resolveFilePath("server.js", "", "runtime");
+		if (!fs.existsSync(serverJs.path)) {
+			console.error("❌ server.js not found. Cannot start Socket.IO server.");
+			console.log(
+				"💡 Run 'gxdev publish server.js' to create a local copy, or ensure you're in a GxP project directory"
+			);
+			process.exit(1);
+		}
+		serverJsPath = serverJs.path;
+		console.log(
+			`📡 Starting Socket.IO server with nodemon... (${
+				serverJs.isLocal ? "local" : "package"
+			} version)`
+		);
+		console.log(`📁 Using: ${serverJsPath}`);
+	}
+
+	// Check for local dev files, otherwise use runtime versions
+	// These files can be published for customization: gxdev publish vite.config.js
+	let viteConfigPath = paths.viteConfigPath;
+	const localViteConfigPath = path.join(projectPath, "vite.config.js");
+	const localIndexHtml = path.join(projectPath, "index.html");
+	const localMainJs = path.join(projectPath, "main.js");
+
+	const hasLocalViteConfig = fs.existsSync(localViteConfigPath);
+	const hasLocalIndexHtml = fs.existsSync(localIndexHtml);
+	const hasLocalMainJs = fs.existsSync(localMainJs);
+
+	if (hasLocalViteConfig) {
+		viteConfigPath = localViteConfigPath;
+		console.log("📁 Using local vite.config.js");
+	}
+	if (hasLocalIndexHtml) {
+		console.log("📁 Using local index.html");
+	}
+	if (hasLocalMainJs) {
+		console.log("📁 Using local main.js");
+	}
+
+	// Log if using all runtime files (default)
+	if (!hasLocalViteConfig && !hasLocalIndexHtml && !hasLocalMainJs) {
+		console.log("📦 Using runtime dev files (publish to customize)");
+	}
+
+	// Only set environment variables if they're not already set (allows .env to take precedence)
+	const envVars = [];
+
+	// Set variables only if not already defined in environment
+	if (!process.env.NODE_LOG_LEVEL) {
+		envVars.push(
+			`${exportCmd} NODE_LOG_LEVEL=${argv["node-log-level"] || "info"}`
+		);
+	}
+	if (!process.env.NODE_PORT) {
+		envVars.push(`${exportCmd} NODE_PORT=${finalPort}`);
+	}
+	if (!process.env.COMPONENT_PATH) {
+		envVars.push(
+			`${exportCmd} COMPONENT_PATH=${
+				argv["component-path"] || "./src/Plugin.vue"
+			}`
+		);
+	}
+
+	// Always set HTTPS-related variables (these are dynamic)
+	envVars.push(`${exportCmd} USE_HTTPS=${useHttps ? "true" : "false"}`);
+	envVars.push(`${exportCmd} CERT_PATH=${certPath}`);
+	envVars.push(`${exportCmd} KEY_PATH=${keyPath}`);
+
+	// Set mock API flag if requested
+	if (withMock) {
+		envVars.push(`${exportCmd} MOCK_API_ENABLED=true`);
+	}
+
+	// Check for browser extension flags
+	const launchFirefox = argv.firefox;
+	const launchChrome = argv.chrome;
+
+	// Get browser extension configurations
+	let firefoxConfig = null;
+	let chromeConfig = null;
+
+	if (launchFirefox) {
+		firefoxConfig = getBrowserExtensionConfig("firefox", projectPath, paths, {
+			useHttps,
+			port: finalPort,
+		});
+		if (firefoxConfig) {
+			console.log("🦊 Firefox extension will launch with dev server");
+			console.log(`📁 Extension path: ${firefoxConfig.extensionPath}`);
+			console.log(`🌐 Start URL: ${firefoxConfig.startUrl}`);
+		} else {
+			console.warn("⚠️ Firefox extension not found, skipping");
+		}
+	}
+
+	if (launchChrome) {
+		chromeConfig = getBrowserExtensionConfig("chrome", projectPath, paths, {
+			useHttps,
+			port: finalPort,
+		});
+		if (chromeConfig) {
+			console.log("🚀 Chrome extension will launch with dev server");
+			console.log(`📁 Extension path: ${chromeConfig.extensionPath}`);
+			console.log(`🌐 Start URL: ${chromeConfig.startUrl}`);
+		} else {
+			console.warn("⚠️ Chrome extension not found, skipping");
+		}
+	}
+
+	// Build the command based on what's requested
+	let command;
+
+	// Collect all processes to run
+	const processes = [];
+	const names = [];
+	const colors = [];
+
+	// Vite is always included
+	const viteCommand = [
+		...envVars,
+		`npx vite dev --config "${viteConfigPath}"`,
+	].join(" && ");
+	processes.push(`"${viteCommand}"`);
+	names.push("VITE");
+	colors.push("cyan");
+
+	// Socket server (optional)
+	if (withSocket && serverJsPath) {
+		processes.push(`"npx nodemon \\"${serverJsPath}\\""`);
+		names.push("SOCKET");
+		colors.push("green");
+	}
+
+	// Firefox extension (optional)
+	if (firefoxConfig) {
+		processes.push(`"${firefoxConfig.command}"`);
+		names.push(firefoxConfig.name);
+		colors.push(firefoxConfig.color);
+	}
+
+	// Chrome extension (optional)
+	if (chromeConfig) {
+		processes.push(`"${chromeConfig.command}"`);
+		names.push(chromeConfig.name);
+		colors.push(chromeConfig.color);
+	}
+
+	// Build the final command
+	if (processes.length > 1) {
+		// Use concurrently to run multiple processes
+		command = `npx concurrently --names "${names.join(
+			","
+		)}" --prefix-colors "${colors.join(",")}" ${processes.join(" ")}`;
+	} else {
+		// Just run Vite dev server alone
+		command = [...envVars, `npx vite dev --config "${viteConfigPath}"`].join(
+			" && "
+		);
+	}
+
+	shell.exec(command);
+}
+
+module.exports = {
+	devCommand,
+};

package/bin/lib/commands/extensions.js

@@ -0,0 +1,298 @@
+/**
+ * Extensions Command
+ *
+ * Manages browser extensions for Firefox and Chrome.
+ */
+
+const path = require("path");
+const fs = require("fs");
+const shell = require("shelljs");
+const { findProjectRoot, resolveGxPaths } = require("../utils");
+
+/**
+ * Launch Firefox with extension command
+ */
+function extensionFirefoxCommand() {
+	const projectPath = findProjectRoot();
+	let extensionPath = path.join(projectPath, "browser-extensions", "firefox");
+
+	// If local extension doesn't exist, try to use the toolkit's own extensions
+	if (!fs.existsSync(extensionPath)) {
+		const paths = resolveGxPaths();
+		const toolkitExtensionPath = path.join(
+			paths.packageRoot,
+			"browser-extensions",
+			"firefox"
+		);
+
+		if (fs.existsSync(toolkitExtensionPath)) {
+			console.log("🔍 Using GxToolkit's built-in Firefox extension");
+			extensionPath = toolkitExtensionPath;
+		} else {
+			console.error("❌ Firefox extension directory not found");
+			console.log(
+				"📁 Looking for extensions in:",
+				path.join(projectPath, "browser-extensions", "firefox")
+			);
+			console.log(
+				"💡 Run 'gxdev init' to create a project with browser extensions"
+			);
+			process.exit(1);
+		}
+	} else {
+		console.log("🔍 Using project's Firefox extension");
+	}
+
+	console.log("🦊 Launching Firefox with extension...");
+	console.log("📁 Extension path:", extensionPath);
+	shell.exec(`npx web-ext run --source-dir "${extensionPath}"`);
+}
+
+/**
+ * Launch Chrome with extension command
+ */
+function extensionChromeCommand() {
+	const projectPath = findProjectRoot();
+	let extensionPath = path.join(projectPath, "browser-extensions", "chrome");
+	let scriptPath = path.join(projectPath, "scripts", "launch-chrome.js");
+
+	// Check if we have a local extension first
+	if (!fs.existsSync(extensionPath)) {
+		const paths = resolveGxPaths();
+		const toolkitExtensionPath = path.join(
+			paths.packageRoot,
+			"browser-extensions",
+			"chrome"
+		);
+
+		if (fs.existsSync(toolkitExtensionPath)) {
+			console.log("🔍 Using GxToolkit's built-in Chrome extension");
+			extensionPath = toolkitExtensionPath;
+			// Use the toolkit's script instead
+			scriptPath = path.join(paths.packageRoot, "scripts", "launch-chrome.js");
+		} else {
+			console.error("❌ Chrome extension directory not found");
+			console.log(
+				"📁 Looking for extensions in:",
+				path.join(projectPath, "browser-extensions", "chrome")
+			);
+			console.log(
+				"💡 Run 'gxdev init' to create a project with browser extensions"
+			);
+			process.exit(1);
+		}
+	} else {
+		console.log("🔍 Using project's Chrome extension");
+	}
+
+	// Verify script exists
+	if (!fs.existsSync(scriptPath)) {
+		console.error(
+			"❌ Chrome launcher script not found. Run 'gxdev init' to create it."
+		);
+		process.exit(1);
+	}
+
+	console.log("🚀 Launching Chrome with extension...");
+	console.log("📁 Extension path:", extensionPath);
+
+	// Set the extension path as an environment variable for the script
+	process.env.CHROME_EXTENSION_PATH = extensionPath;
+	shell.exec(`node "${scriptPath}"`);
+}
+
+/**
+ * Install extension permanently in local browser
+ */
+function extensionInstallCommand(argv) {
+	const browser = argv.browser;
+	const paths = resolveGxPaths();
+
+	if (!browser || !["chrome", "firefox"].includes(browser)) {
+		console.log("Usage: gxdev ext:install <chrome|firefox>");
+		console.log("");
+		console.log("This command helps you permanently install the extension");
+		console.log("in your local browser for development.");
+		process.exit(1);
+	}
+
+	const extensionPath = path.join(
+		paths.packageRoot,
+		"browser-extensions",
+		browser
+	);
+
+	if (!fs.existsSync(extensionPath)) {
+		console.error(
+			`❌ ${browser} extension directory not found at:`,
+			extensionPath
+		);
+		process.exit(1);
+	}
+
+	console.log("");
+	console.log(`📦 Extension path: ${extensionPath}`);
+	console.log("");
+
+	if (browser === "chrome") {
+		console.log("🚀 Chrome Permanent Installation Instructions:");
+		console.log("─".repeat(50));
+		console.log("");
+		console.log("1. Open Chrome and navigate to:");
+		console.log("   chrome://extensions/");
+		console.log("");
+		console.log('2. Enable "Developer mode" (toggle in top right corner)');
+		console.log("");
+		console.log('3. Click "Load unpacked" button');
+		console.log("");
+		console.log("4. Select this directory:");
+		console.log(`   ${extensionPath}`);
+		console.log("");
+		console.log("─".repeat(50));
+		console.log("✅ The extension will persist across browser restarts.");
+		console.log("🔄 After code changes, click the refresh icon on the");
+		console.log("   extension card in chrome://extensions/ to reload.");
+		console.log("");
+
+		// Try to open Chrome to the extensions page
+		const openCommand =
+			process.platform === "darwin"
+				? 'open -a "Google Chrome" "chrome://extensions/"'
+				: process.platform === "win32"
+				? 'start chrome "chrome://extensions/"'
+				: 'google-chrome "chrome://extensions/"';
+
+		console.log("🌐 Attempting to open Chrome extensions page...");
+		shell.exec(openCommand, { silent: true });
+	} else if (browser === "firefox") {
+		console.log("🦊 Firefox Installation Instructions:");
+		console.log("─".repeat(50));
+		console.log("");
+		console.log("Option 1: Temporary Add-on (easiest, but doesn't persist)");
+		console.log("─".repeat(50));
+		console.log("1. Open Firefox and navigate to:");
+		console.log("   about:debugging#/runtime/this-firefox");
+		console.log("");
+		console.log('2. Click "Load Temporary Add-on..."');
+		console.log("");
+		console.log("3. Select any file in this directory:");
+		console.log(`   ${extensionPath}`);
+		console.log("");
+		console.log("⚠️  Note: Temporary add-ons are removed when Firefox closes.");
+		console.log("");
+		console.log("─".repeat(50));
+		console.log(
+			"Option 2: Persistent Installation (Firefox Developer/Nightly)"
+		);
+		console.log("─".repeat(50));
+		console.log("1. Use Firefox Developer Edition or Firefox Nightly");
+		console.log("");
+		console.log("2. Go to about:config and set:");
+		console.log("   xpinstall.signatures.required = false");
+		console.log("");
+		console.log("3. Then go to about:addons");
+		console.log("");
+		console.log("4. Click the gear icon and select:");
+		console.log('   "Install Add-on From File..."');
+		console.log("");
+		console.log("5. Select the manifest.json in:");
+		console.log(`   ${extensionPath}`);
+		console.log("");
+
+		// Try to open Firefox to the debugging page
+		const openCommand =
+			process.platform === "darwin"
+				? 'open -a "Firefox" "about:debugging#/runtime/this-firefox"'
+				: process.platform === "win32"
+				? 'start firefox "about:debugging#/runtime/this-firefox"'
+				: 'firefox "about:debugging#/runtime/this-firefox"';
+
+		console.log("🌐 Attempting to open Firefox debugging page...");
+		shell.exec(openCommand, { silent: true });
+	}
+}
+
+/**
+ * Build extensions command
+ */
+function extensionBuildCommand() {
+	const projectPath = findProjectRoot();
+	const paths = resolveGxPaths();
+
+	console.log("📦 Building browser extensions...");
+
+	// Build Firefox extension
+	let firefoxPath = path.join(projectPath, "browser-extensions", "firefox");
+	let useProjectExtensions = true;
+
+	if (!fs.existsSync(firefoxPath)) {
+		// Try toolkit's extensions
+		const toolkitFirefoxPath = path.join(
+			paths.packageRoot,
+			"browser-extensions",
+			"firefox"
+		);
+		if (fs.existsSync(toolkitFirefoxPath)) {
+			firefoxPath = toolkitFirefoxPath;
+			useProjectExtensions = false;
+			console.log("🔍 Using GxToolkit's built-in Firefox extension");
+		}
+	}
+
+	if (fs.existsSync(firefoxPath)) {
+		console.log("🦊 Building Firefox extension...");
+		const outputDir = useProjectExtensions
+			? "dist/firefox"
+			: path.join(projectPath, "dist/firefox");
+		shell.exec(
+			`npx web-ext build --source-dir "${firefoxPath}" --artifacts-dir "${outputDir}"`
+		);
+	} else {
+		console.log("⚠️ No Firefox extension found to build");
+	}
+
+	// Build Chrome extension
+	let chromeScriptPath = path.join(projectPath, "scripts", "pack-chrome.js");
+	let chromeExtensionPath = path.join(
+		projectPath,
+		"browser-extensions",
+		"chrome"
+	);
+
+	if (!fs.existsSync(chromeScriptPath) || !fs.existsSync(chromeExtensionPath)) {
+		// Try toolkit's scripts and extensions
+		const toolkitScriptPath = path.join(
+			paths.packageRoot,
+			"scripts",
+			"pack-chrome.js"
+		);
+		const toolkitChromePath = path.join(
+			paths.packageRoot,
+			"browser-extensions",
+			"chrome"
+		);
+
+		if (fs.existsSync(toolkitScriptPath) && fs.existsSync(toolkitChromePath)) {
+			chromeScriptPath = toolkitScriptPath;
+			chromeExtensionPath = toolkitChromePath;
+			console.log("🔍 Using GxToolkit's built-in Chrome extension");
+		}
+	}
+
+	if (fs.existsSync(chromeScriptPath)) {
+		console.log("🚀 Building Chrome extension...");
+		// Set environment variable for the script to know where the extension is
+		process.env.CHROME_EXTENSION_PATH = chromeExtensionPath;
+		process.env.CHROME_BUILD_OUTPUT = path.join(projectPath, "dist/chrome");
+		shell.exec(`node "${chromeScriptPath}"`);
+	} else {
+		console.log("⚠️ No Chrome extension found to build");
+	}
+}
+
+module.exports = {
+	extensionFirefoxCommand,
+	extensionChromeCommand,
+	extensionBuildCommand,
+	extensionInstallCommand,
+};

package/bin/lib/commands/index.js

@@ -0,0 +1,35 @@
+/**
+ * Commands Index
+ *
+ * Re-exports all command modules for convenient importing.
+ */
+
+const { initCommand } = require("./init");
+const { devCommand } = require("./dev");
+const { buildCommand } = require("./build");
+const { publishCommand } = require("./publish");
+const { setupSSLCommand } = require("./ssl");
+const { datastoreCommand } = require("./datastore");
+const { socketCommand } = require("./socket");
+const { assetsCommand } = require("./assets");
+const {
+	extensionFirefoxCommand,
+	extensionChromeCommand,
+	extensionBuildCommand,
+	extensionInstallCommand,
+} = require("./extensions");
+
+module.exports = {
+	initCommand,
+	devCommand,
+	buildCommand,
+	publishCommand,
+	setupSSLCommand,
+	datastoreCommand,
+	socketCommand,
+	assetsCommand,
+	extensionFirefoxCommand,
+	extensionChromeCommand,
+	extensionBuildCommand,
+	extensionInstallCommand,
+};