@gxp-dev/tools 2.0.5

package/bin/lib/commands/init.js

@@ -0,0 +1,307 @@
+/**
+ * Init Command
+ *
+ * Sets up a new GxP project or updates an existing one.
+ */
+
+const path = require("path");
+const fs = require("fs");
+const { REQUIRED_DEPENDENCIES } = require("../constants");
+const {
+	findProjectRoot,
+	resolveGxPaths,
+	promptUser,
+	safeCopyFile,
+	createPackageJson,
+	installDependencies,
+	updateExistingProject,
+	ensureMkcertInstalled,
+	generateSSLCertificates,
+	updateEnvWithCertPaths,
+} = require("../utils");
+
+/**
+ * Initialize command - sets up a new GxP project or updates existing one
+ */
+async function initCommand(argv) {
+	const currentDir = process.cwd();
+	const hasPackageJson = fs.existsSync(path.join(currentDir, "package.json"));
+	let projectPath = currentDir;
+	let projectName;
+	let sslSetup = false;
+
+	if (!hasPackageJson && !argv.name) {
+		// New project - prompt for name
+		projectName = await promptUser("Enter project name: ");
+		if (!projectName) {
+			console.error("Project name is required!");
+			process.exit(1);
+		}
+
+		// Create project directory
+		projectPath = path.join(currentDir, projectName);
+		if (fs.existsSync(projectPath)) {
+			console.error(`Directory ${projectName} already exists!`);
+			process.exit(1);
+		}
+
+		console.log(`Creating new project: ${projectName}`);
+		fs.mkdirSync(projectPath, { recursive: true });
+
+		// Create package.json
+		createPackageJson(projectPath, projectName);
+
+		// Install dependencies
+		installDependencies(projectPath);
+	} else if (hasPackageJson) {
+		// Existing project - update it
+		console.log("Updating existing project...");
+		updateExistingProject(projectPath);
+	} else if (argv.name) {
+		// New project with provided name
+		projectName = argv.name;
+		projectPath = path.join(currentDir, projectName);
+
+		if (fs.existsSync(projectPath)) {
+			console.error(`Directory ${projectName} already exists!`);
+			process.exit(1);
+		}
+
+		console.log(`Creating new project: ${projectName}`);
+		fs.mkdirSync(projectPath, { recursive: true });
+		createPackageJson(projectPath, projectName);
+		installDependencies(projectPath);
+	}
+
+	// Copy template files
+	// Note: PortalContainer.vue (formerly App.vue) is now in runtime/ and accessed via @gx-runtime alias
+	// Users don't need a copy - it's immutable and loaded from node_modules
+	const paths = resolveGxPaths();
+	// Note: main.js, index.html, and vite.config.js are NOT copied by default.
+	// They are served from the runtime directory. Users can publish them
+	// for customization using: gxdev publish main.js / index.html / vite.config.js
+	const filesToCopy = [
+		{
+			src: "theme-layouts/SystemLayout.vue",
+			dest: "theme-layouts/SystemLayout.vue",
+			desc: "SystemLayout.vue",
+		},
+		{
+			src: "theme-layouts/PrivateLayout.vue",
+			dest: "theme-layouts/PrivateLayout.vue",
+			desc: "PrivateLayout.vue",
+		},
+		{
+			src: "theme-layouts/PublicLayout.vue",
+			dest: "theme-layouts/PublicLayout.vue",
+			desc: "PublicLayout.vue",
+		},
+		{
+			src: "theme-layouts/AdditionalStyling.css",
+			dest: "theme-layouts/AdditionalStyling.css",
+			desc: "AdditionalStyling.css",
+		},
+		{
+			src: "src/stores/index.js",
+			dest: "src/stores/index.js",
+			desc: "Pinia store setup",
+		},
+		{
+			src: "src/Plugin.vue",
+			dest: "src/Plugin.vue",
+			desc: "Plugin.vue (Your app entry point)",
+		},
+		{
+			src: "src/DemoPage.vue",
+			dest: "src/DemoPage.vue",
+			desc: "DemoPage.vue (Example component)",
+		},
+		{
+			src: "app-manifest.json",
+			dest: "app-manifest.json",
+			desc: "app-manifest.json",
+		},
+		{ src: "env.example", dest: ".env.example", desc: ".env.example" },
+		{ src: "gitignore", dest: ".gitignore", desc: ".gitignore" },
+		{
+			src: "README.md",
+			dest: "README.md",
+			desc: "README.md (Project documentation)",
+		},
+	];
+
+	// Copy template files
+	filesToCopy.forEach((file) => {
+		const srcPath = path.join(paths.templateDir, file.src);
+		const destPath = path.join(projectPath, file.dest);
+		safeCopyFile(srcPath, destPath, file.desc);
+	});
+
+	// Create /src/assets/ directory for user assets
+	const assetsDir = path.join(projectPath, "src", "assets");
+	if (!fs.existsSync(assetsDir)) {
+		fs.mkdirSync(assetsDir, { recursive: true });
+		// Add a .gitkeep to ensure the directory is tracked
+		fs.writeFileSync(path.join(assetsDir, ".gitkeep"), "");
+		console.log("✓ Created src/assets/ directory for project assets");
+	}
+
+	// Create .env file from .env.example
+	const envExamplePath = path.join(projectPath, ".env.example");
+	const envPath = path.join(projectPath, ".env");
+	if (fs.existsSync(envExamplePath) && !fs.existsSync(envPath)) {
+		fs.copyFileSync(envExamplePath, envPath);
+		console.log("✓ Created .env file from .env.example");
+	}
+
+	// Copy extension management scripts for new projects
+	if (!hasPackageJson || argv.name) {
+		const scriptsDir = path.join(projectPath, "scripts");
+		if (!fs.existsSync(scriptsDir)) {
+			fs.mkdirSync(scriptsDir, { recursive: true });
+		}
+
+		// Copy launch-chrome.js script
+		const launchChromeSource = path.join(
+			paths.templateDir,
+			"../scripts/launch-chrome.js"
+		);
+		const launchChromeDest = path.join(scriptsDir, "launch-chrome.js");
+		if (fs.existsSync(launchChromeSource)) {
+			safeCopyFile(
+				launchChromeSource,
+				launchChromeDest,
+				"Chrome launcher script"
+			);
+		}
+
+		// Copy pack-chrome.js script
+		const packChromeSource = path.join(
+			paths.templateDir,
+			"../scripts/pack-chrome.js"
+		);
+		const packChromeDest = path.join(scriptsDir, "pack-chrome.js");
+		if (fs.existsSync(packChromeSource)) {
+			safeCopyFile(packChromeSource, packChromeDest, "Chrome packaging script");
+		}
+
+		// Copy socket events directory for simulation (root level for CLI access)
+		const socketEventsSource = paths.socketEventsDir;
+		const socketEventsDest = path.join(projectPath, "socket-events");
+		if (fs.existsSync(socketEventsSource)) {
+			if (!fs.existsSync(socketEventsDest)) {
+				fs.mkdirSync(socketEventsDest, { recursive: true });
+			}
+
+			const eventFiles = fs
+				.readdirSync(socketEventsSource)
+				.filter((file) => file.endsWith(".json"));
+			eventFiles.forEach((file) => {
+				const srcPath = path.join(socketEventsSource, file);
+				const destPath = path.join(socketEventsDest, file);
+				safeCopyFile(srcPath, destPath, `Socket event: ${file}`);
+			});
+		}
+	}
+
+	// Setup SSL certificates for new projects
+	if (!hasPackageJson || argv.name) {
+		// Ask user if they want to set up SSL certificates
+		const sslChoice = await promptUser(
+			"Do you want to set up SSL certificates for HTTPS development? (Y/n): "
+		);
+		sslSetup =
+			sslChoice.toLowerCase() !== "n" && sslChoice.toLowerCase() !== "no";
+
+		if (sslSetup) {
+			console.log("\n🔒 Setting up HTTPS development environment...");
+			ensureMkcertInstalled();
+			const certs = generateSSLCertificates(projectPath);
+
+			// Update .env file with actual certificate names if SSL setup was successful
+			if (certs) {
+				updateEnvWithCertPaths(projectPath, certs);
+			}
+		} else {
+			console.log(
+				"\n⚠️  Skipping SSL setup. You can set it up later with: npm run setup-ssl"
+			);
+		}
+	}
+
+	console.log("✅ Project setup complete!");
+	console.log(
+		"🎨 GX ComponentKit component library included for rapid kiosk development!"
+	);
+	console.log("🗃️ GxP Datastore included with Pinia integration!");
+	if (!hasPackageJson) {
+		console.log(`📁 Navigate to your project: cd ${projectName}`);
+	}
+	console.log("⚙️ Environment file (.env) ready - customize as needed");
+
+	if (sslSetup) {
+		console.log("🔒 Start HTTPS development with Socket.IO: npm run dev");
+		console.log("🔒 Start HTTPS development only: npm run dev-app");
+		console.log("🌐 Start HTTP development: npm run dev-http");
+	} else {
+		console.log("🌐 Start development: npm run dev-http");
+		console.log("🔧 Setup SSL certificates: npm run setup-ssl");
+		console.log("🔒 Then use HTTPS development: npm run dev");
+	}
+	console.log("");
+	console.log("📖 Project structure:");
+	console.log("   • src/Plugin.vue - Your app entry point (customize this!)");
+	console.log("   • src/DemoPage.vue - Example component");
+	console.log("   • theme-layouts/ - Customizable layout templates");
+	console.log(
+		"   • main.js - Development entry (loads PortalContainer from toolkit)"
+	);
+	console.log("📚 Check README.md for detailed usage instructions");
+
+	// For new projects, offer to launch TUI
+	if (projectName) {
+		console.log("");
+		const launchChoice = await promptUser(
+			"Would you like to open the project in the interactive TUI? (Y/n): "
+		);
+		const shouldLaunch =
+			launchChoice.toLowerCase() !== "n" && launchChoice.toLowerCase() !== "no";
+
+		if (shouldLaunch) {
+			console.log(`\n🚀 Launching gxdev TUI in ${projectName}...`);
+			// Change to project directory and launch TUI
+			process.chdir(projectPath);
+
+			// Try to launch TUI
+			const tuiPath = path.join(
+				__dirname,
+				"..",
+				"..",
+				"..",
+				"dist",
+				"tui",
+				"index.js"
+			);
+			if (fs.existsSync(tuiPath)) {
+				try {
+					const { startTUI } = await import(tuiPath);
+					startTUI({ autoStart: [], args: {} });
+				} catch (err) {
+					console.error("Could not launch TUI:", err.message);
+					console.log(`\nTo start manually:\n  cd ${projectName}\n  gxdev`);
+				}
+			} else {
+				console.log(
+					'TUI not available. Run "npm run build:tui" in gx-devtools first.'
+				);
+				console.log(`\nTo start manually:\n  cd ${projectName}\n  gxdev`);
+			}
+		} else {
+			console.log(`\nTo get started:\n  cd ${projectName}\n  gxdev`);
+		}
+	}
+}
+
+module.exports = {
+	initCommand,
+};

package/bin/lib/commands/publish.js

@@ -0,0 +1,189 @@
+/**
+ * Publish Command
+ *
+ * Copies package files to local project for customization.
+ */
+
+const path = require("path");
+const fs = require("fs");
+const {
+	findProjectRoot,
+	resolveGxPaths,
+	promptUser,
+	safeCopyFile,
+} = require("../utils");
+
+/**
+ * Publish command - copies package files to local project
+ */
+async function publishCommand(argv) {
+	const projectPath = findProjectRoot();
+	const paths = resolveGxPaths();
+
+	const fileName = argv.file || argv._[1]; // Support both --file and positional argument
+
+	if (!fileName) {
+		console.log("📦 Available files to publish:");
+		console.log("");
+		console.log("  Development files (customize dev environment):");
+		console.log("  • main.js            - Development entry point");
+		console.log("  • index.html         - HTML template");
+		console.log("  • vite.config.js     - Vite build configuration");
+		console.log("");
+		console.log("  Runtime files (advanced customization):");
+		console.log("  • server.js          - Socket.IO server file");
+		console.log("  • gxpPortalConfigStore.js - GxP datastore");
+		console.log("");
+		console.log("💡 Usage:");
+		console.log("  gxdev publish main.js");
+		console.log("  gxdev publish vite.config.js");
+		console.log("  gxdev publish server.js");
+		return;
+	}
+
+	const publishableFiles = {
+		"main.js": {
+			src: "main.js",
+			dest: "main.js",
+			desc: "Development entry point",
+			location: "runtime",
+		},
+		"index.html": {
+			src: "index.html",
+			dest: "index.html",
+			desc: "HTML template",
+			location: "runtime",
+		},
+		"vite.config.js": {
+			src: "vite.config.js",
+			dest: "vite.config.js",
+			desc: "Vite build configuration",
+			location: "runtime",
+		},
+		"server.js": {
+			src: "server.js",
+			dest: "server.js",
+			desc: "Socket.IO server file",
+			location: "runtime",
+		},
+		"gxpPortalConfigStore.js": {
+			src: "stores/gxpPortalConfigStore.js",
+			dest: "src/stores/gxpPortalConfigStore.js",
+			desc: "GxP datastore",
+			location: "runtime",
+		},
+	};
+
+	const fileConfig = publishableFiles[fileName];
+	if (!fileConfig) {
+		console.error(`❌ Unknown file: ${fileName}`);
+		console.log(
+			"📦 Available files:",
+			Object.keys(publishableFiles).join(", ")
+		);
+		process.exit(1);
+	}
+
+	// Get source path from appropriate directory
+	const sourceDir =
+		fileConfig.location === "runtime" ? paths.runtimeDir : paths.templateDir;
+	const srcPath = path.join(sourceDir, fileConfig.src);
+	const destPath = path.join(projectPath, fileConfig.dest);
+
+	if (!fs.existsSync(srcPath)) {
+		console.error(`❌ Source file not found: ${srcPath}`);
+		process.exit(1);
+	}
+
+	// Check if local file already exists
+	if (fs.existsSync(destPath)) {
+		const overwrite = await promptUser(
+			`📁 ${fileConfig.dest} already exists. Overwrite? (y/N): `
+		);
+		if (overwrite.toLowerCase() !== "y" && overwrite.toLowerCase() !== "yes") {
+			console.log("📦 Publish cancelled");
+			return;
+		}
+	}
+
+	// Ensure destination directory exists
+	const destDir = path.dirname(destPath);
+	if (!fs.existsSync(destDir)) {
+		fs.mkdirSync(destDir, { recursive: true });
+	}
+
+	// Copy the file
+	fs.copyFileSync(srcPath, destPath);
+	console.log(`Creating ${fileConfig.desc}`);
+	console.log(`✅ Published ${fileName} to project`);
+	console.log(`📁 Local file: ${fileConfig.dest}`);
+
+	// Special handling for index.html - update main.js reference to local path
+	if (fileName === "index.html") {
+		try {
+			let content = fs.readFileSync(destPath, "utf-8");
+			// Update the runtime reference to local reference
+			if (content.includes('src="/@gx-runtime/main.js"')) {
+				content = content.replace(
+					'src="/@gx-runtime/main.js"',
+					'src="/main.js"'
+				);
+				fs.writeFileSync(destPath, content);
+				console.log("📝 Updated index.html to reference local main.js");
+				console.log(
+					"💡 Make sure to also publish main.js: gxdev publish main.js"
+				);
+			}
+		} catch (error) {
+			console.warn("⚠️ Could not update index.html:", error.message);
+		}
+	}
+
+	// Special handling for gxpPortalConfigStore.js - update the import in stores/index.js
+	if (fileName === "gxpPortalConfigStore.js") {
+		const storeIndexPath = path.join(projectPath, "src/stores/index.js");
+		if (fs.existsSync(storeIndexPath)) {
+			try {
+				let content = fs.readFileSync(storeIndexPath, "utf-8");
+				// Match both old (config) and new (runtime) import paths
+				const oldImportPatterns = [
+					"import { useGxpStore } from '@gramercytech/gx-devtools/config/stores/gxpPortalConfigStore.js';",
+					"import { useGxpStore } from '@gramercytech/gx-devtools/config/stores/gxpPortalConfigStore';",
+					"import { useGxpStore } from '@gramercytech/gx-devtools/runtime/stores/gxpPortalConfigStore.js';",
+					"import { useGxpStore } from '@gramercytech/gx-devtools/runtime/stores/gxpPortalConfigStore';",
+					'import { useGxpStore } from "@gramercytech/gx-devtools/runtime/stores/gxpPortalConfigStore";',
+				];
+				const newImport =
+					"import { useGxpStore } from './gxpPortalConfigStore.js';";
+
+				let updated = false;
+				for (const oldImport of oldImportPatterns) {
+					if (content.includes(oldImport)) {
+						content = content.replace(oldImport, newImport);
+						updated = true;
+						break;
+					}
+				}
+
+				if (updated) {
+					fs.writeFileSync(storeIndexPath, content);
+					console.log(
+						"📝 Updated stores/index.js to use local gxpPortalConfigStore.js"
+					);
+				}
+			} catch (error) {
+				console.warn(
+					"⚠️ Could not update stores/index.js import:",
+					error.message
+				);
+			}
+		}
+	}
+
+	console.log("💡 Future gxdev commands will now use your local copy");
+	console.log("   Delete the local file to fall back to package version");
+}
+
+module.exports = {
+	publishCommand,
+};

package/bin/lib/commands/socket.js

@@ -0,0 +1,158 @@
+/**
+ * Socket Command
+ *
+ * Simulates socket events for development testing.
+ */
+
+const path = require("path");
+const fs = require("fs");
+const { findProjectRoot, resolveGxPaths } = require("../utils");
+
+/**
+ * Socket simulation command - sends JSON events to the Socket.IO server
+ */
+async function socketCommand(argv) {
+	const action = argv.action;
+
+	if (action === "list") {
+		listSocketEvents();
+	} else if (action === "send") {
+		await sendSocketEvent(argv.event, argv.identifier);
+	} else {
+		console.error("❌ Invalid socket action. Use 'list' or 'send'");
+		process.exit(1);
+	}
+}
+
+function listSocketEvents() {
+	const projectPath = findProjectRoot();
+	const paths = resolveGxPaths();
+
+	// Check local project socket-events first, then fall back to toolkit's socket-events
+	let eventsDir = path.join(projectPath, "socket-events");
+	if (!fs.existsSync(eventsDir)) {
+		eventsDir = paths.socketEventsDir;
+	}
+
+	if (!fs.existsSync(eventsDir)) {
+		console.log("❌ No socket events directory found");
+		console.log(`📁 Looking in: ${eventsDir}`);
+		return;
+	}
+
+	const eventFiles = fs
+		.readdirSync(eventsDir)
+		.filter((file) => file.endsWith(".json"));
+
+	if (eventFiles.length === 0) {
+		console.log("❌ No socket event files found");
+		return;
+	}
+
+	console.log("📡 Available socket events:");
+	console.log("");
+
+	eventFiles.forEach((file) => {
+		const eventPath = path.join(eventsDir, file);
+		try {
+			const eventData = JSON.parse(fs.readFileSync(eventPath, "utf-8"));
+			const eventName = path.basename(file, ".json");
+			console.log(`🎯 ${eventName}`);
+			console.log(`   Event: ${eventData.event}`);
+			console.log(`   Channel: ${eventData.channel}`);
+			if (eventData.data.id) {
+				console.log(`   Data ID: ${eventData.data.id}`);
+			}
+			console.log("");
+		} catch (error) {
+			console.error(`❌ Error reading ${file}: ${error.message}`);
+		}
+	});
+
+	console.log("💡 Usage:");
+	console.log("   gxdev socket send --event AiSessionMessageCreated");
+	console.log(
+		"   gxdev socket send --event SocialStreamPostCreated --identifier social_stream"
+	);
+}
+
+async function sendSocketEvent(eventName, identifier) {
+	if (!eventName) {
+		console.error("❌ Event name is required");
+		console.log("💡 Use: gxdev socket send --event <EventName>");
+		process.exit(1);
+	}
+
+	const projectPath = findProjectRoot();
+	const paths = resolveGxPaths();
+	const socketIoPort = process.env.SOCKET_IO_PORT || 3069;
+
+	// Check local project socket-events first, then fall back to toolkit's socket-events
+	let eventsDir = path.join(projectPath, "socket-events");
+	if (!fs.existsSync(eventsDir)) {
+		eventsDir = paths.socketEventsDir;
+	}
+
+	const eventPath = path.join(eventsDir, `${eventName}.json`);
+
+	if (!fs.existsSync(eventPath)) {
+		console.error(`❌ Event file not found: ${eventName}.json`);
+		console.log(`📁 Looking in: ${eventsDir}`);
+		console.log("💡 Use 'gxdev socket list' to see available events");
+		process.exit(1);
+	}
+
+	try {
+		let eventData = JSON.parse(fs.readFileSync(eventPath, "utf-8"));
+
+		// If identifier is provided, update the channel
+		if (identifier) {
+			// Try to extract model from the original channel
+			const channelParts = eventData.channel.split(".");
+			if (channelParts.length >= 2) {
+				const model = channelParts[1];
+				eventData.channel = `private.${model}.${identifier}`;
+			}
+		}
+
+		// Send the event via HTTP to the Socket.IO server
+		const socketUrl = `https://localhost:${socketIoPort}`;
+
+		console.log(`📡 Sending socket event: ${eventData.event}`);
+		console.log(`📺 Channel: ${eventData.channel}`);
+		console.log(`📦 Data:`, JSON.stringify(eventData.data, null, 2));
+
+		// Use axios to send the event to our Socket.IO server
+		const axios = require("axios");
+
+		try {
+			await axios.post(`${socketUrl}/emit`, {
+				event: eventData.event,
+				channel: eventData.channel,
+				data: eventData.data,
+			});
+
+			console.log("✅ Socket event sent successfully!");
+			console.log(
+				"👂 Check your app console for the received event in the store"
+			);
+		} catch (error) {
+			if (error.code === "ECONNREFUSED") {
+				console.error("❌ Cannot connect to Socket.IO server");
+				console.log("💡 Make sure the server is running:");
+				console.log("   npm run dev");
+				console.log("   or");
+				console.log("   nodemon server.js");
+			} else {
+				console.error(`❌ Error sending event: ${error.message}`);
+			}
+		}
+	} catch (error) {
+		console.error(`❌ Error reading event file: ${error.message}`);
+		process.exit(1);
+	}
+}
+
+module.exports = {
+	socketCommand,
+};

package/bin/lib/commands/ssl.js

@@ -0,0 +1,47 @@
+/**
+ * SSL Command
+ *
+ * Sets up SSL certificates for HTTPS development.
+ */
+
+const {
+	findProjectRoot,
+	ensureMkcertInstalled,
+	generateSSLCertificates,
+	updateEnvWithCertPaths,
+} = require("../utils");
+
+/**
+ * Setup SSL certificates command
+ */
+function setupSSLCommand() {
+	const projectPath = findProjectRoot();
+
+	console.log("Setting up SSL certificates for HTTPS development...");
+
+	// Ensure mkcert is available
+	ensureMkcertInstalled();
+
+	// Generate certificates
+	const certs = generateSSLCertificates(projectPath);
+
+	if (certs) {
+		// Update .env file with actual certificate names
+		updateEnvWithCertPaths(projectPath, certs);
+
+		console.log("✅ SSL setup complete!");
+		console.log("🔒 Your development server will now use HTTPS");
+		console.log("📁 Certificates stored in .certs/ directory");
+		console.log(
+			"🚀 Run 'npm run dev' to start HTTPS development with Socket.IO"
+		);
+	} else {
+		console.log(
+			"❌ SSL setup failed. You can still use HTTP with 'npm run dev-http'"
+		);
+	}
+}
+
+module.exports = {
+	setupSSLCommand,
+};