@gxp-dev/tools 2.0.62 → 2.0.64

package/runtime/mock-api/spec-loader.js

@@ -5,22 +5,21 @@
  * Falls back to local files when the platform API is unreachable.
  */
 
-const fs = require("fs");
-const path = require("path");
-const axios = require("axios");
-const https = require("https");
+const fs = require("fs")
+const path = require("path")
+const axios = require("axios")
+const https = require("https")
 
 // Import environment URLs from constants
-let ENVIRONMENT_URLS;
+let ENVIRONMENT_URLS
 try {
 	// When running from node_modules
-	ENVIRONMENT_URLS = require("../../bin/lib/constants").ENVIRONMENT_URLS;
+	ENVIRONMENT_URLS = require("../../bin/lib/constants").ENVIRONMENT_URLS
 } catch {
 	// Fallback for direct execution
-	ENVIRONMENT_URLS = require(path.join(
-		__dirname,
-		"../../bin/lib/constants"
-	)).ENVIRONMENT_URLS;
+	ENVIRONMENT_URLS = require(
+		path.join(__dirname, "../../bin/lib/constants"),
+	).ENVIRONMENT_URLS
 }
 
 // Spec cache
@@ -29,16 +28,16 @@ const cache = {
 	asyncApi: null,
 	webhooks: null,
 	lastFetch: null,
-};
+}
 
 // Default cache TTL (5 minutes)
-const DEFAULT_CACHE_TTL = 5 * 60 * 1000;
+const DEFAULT_CACHE_TTL = 5 * 60 * 1000
 
 /**
  * Get cache TTL from environment or use default
  */
 function getCacheTTL() {
-	return parseInt(process.env.MOCK_API_CACHE_TTL) || DEFAULT_CACHE_TTL;
+	return parseInt(process.env.MOCK_API_CACHE_TTL) || DEFAULT_CACHE_TTL
 }
 
 /**
@@ -47,17 +46,17 @@ function getCacheTTL() {
  * @returns {object} Environment URLs configuration
  */
 function getEnvironmentConfig(env) {
-	const envName = env || process.env.API_ENV || "production";
-	const config = ENVIRONMENT_URLS[envName];
+	const envName = env || process.env.API_ENV || "production"
+	const config = ENVIRONMENT_URLS[envName]
 
 	if (!config) {
 		console.warn(
-			`⚠️  Unknown environment "${envName}", falling back to production`
-		);
-		return ENVIRONMENT_URLS.production;
+			`⚠️  Unknown environment "${envName}", falling back to production`,
+		)
+		return ENVIRONMENT_URLS.production
 	}
 
-	return config;
+	return config
 }
 
 /**
@@ -69,7 +68,7 @@ function createHttpClient() {
 		httpsAgent: new https.Agent({
 			rejectUnauthorized: process.env.NODE_ENV === "production",
 		}),
-	});
+	})
 }
 
 /**
@@ -79,19 +78,19 @@ function createHttpClient() {
  * @returns {object|null} Parsed JSON spec or null on error
  */
 async function fetchSpec(url, specName) {
-	const client = createHttpClient();
+	const client = createHttpClient()
 
 	try {
-		console.log(`📡 Fetching ${specName} from ${url}`);
-		const response = await client.get(url);
-		console.log(`✅ ${specName} loaded successfully`);
-		return response.data;
+		console.log(`📡 Fetching ${specName} from ${url}`)
+		const response = await client.get(url)
+		console.log(`✅ ${specName} loaded successfully`)
+		return response.data
 	} catch (error) {
 		const message = error.response
 			? `HTTP ${error.response.status}`
-			: error.message;
-		console.warn(`⚠️  Failed to fetch ${specName}: ${message}`);
-		return null;
+			: error.message
+		console.warn(`⚠️  Failed to fetch ${specName}: ${message}`)
+		return null
 	}
 }
 
@@ -103,21 +102,21 @@ async function fetchSpec(url, specName) {
  * @returns {object|null} Parsed JSON spec or null if not found
  */
 function loadLocalSpec(projectRoot, filename, specName) {
-	const filePath = path.join(projectRoot, filename);
+	const filePath = path.join(projectRoot, filename)
 
 	if (!fs.existsSync(filePath)) {
-		return null;
+		return null
 	}
 
 	try {
-		console.log(`📁 Loading local ${specName} from ${filename}`);
-		const content = fs.readFileSync(filePath, "utf-8");
-		const spec = JSON.parse(content);
-		console.log(`✅ Local ${specName} loaded successfully`);
-		return spec;
+		console.log(`📁 Loading local ${specName} from ${filename}`)
+		const content = fs.readFileSync(filePath, "utf-8")
+		const spec = JSON.parse(content)
+		console.log(`✅ Local ${specName} loaded successfully`)
+		return spec
 	} catch (error) {
-		console.warn(`⚠️  Failed to parse local ${specName}: ${error.message}`);
-		return null;
+		console.warn(`⚠️  Failed to parse local ${specName}: ${error.message}`)
+		return null
 	}
 }
 
@@ -127,17 +126,17 @@ function loadLocalSpec(projectRoot, filename, specName) {
  * @returns {object|null} OpenAPI spec
  */
 async function fetchOpenApiSpec(projectRoot) {
-	const config = getEnvironmentConfig();
+	const config = getEnvironmentConfig()
 
 	// Try remote first
-	let spec = await fetchSpec(config.openApiSpec, "OpenAPI spec");
+	let spec = await fetchSpec(config.openApiSpec, "OpenAPI spec")
 
 	// Fallback to local
 	if (!spec && projectRoot) {
-		spec = loadLocalSpec(projectRoot, "openapi.json", "OpenAPI spec");
+		spec = loadLocalSpec(projectRoot, "openapi.json", "OpenAPI spec")
 	}
 
-	return spec;
+	return spec
 }
 
 /**
@@ -146,17 +145,17 @@ async function fetchOpenApiSpec(projectRoot) {
  * @returns {object|null} AsyncAPI spec
  */
 async function fetchAsyncApiSpec(projectRoot) {
-	const config = getEnvironmentConfig();
+	const config = getEnvironmentConfig()
 
 	// Try remote first
-	let spec = await fetchSpec(config.asyncApiSpec, "AsyncAPI spec");
+	let spec = await fetchSpec(config.asyncApiSpec, "AsyncAPI spec")
 
 	// Fallback to local
 	if (!spec && projectRoot) {
-		spec = loadLocalSpec(projectRoot, "asyncapi.json", "AsyncAPI spec");
+		spec = loadLocalSpec(projectRoot, "asyncapi.json", "AsyncAPI spec")
 	}
 
-	return spec;
+	return spec
 }
 
 /**
@@ -165,17 +164,17 @@ async function fetchAsyncApiSpec(projectRoot) {
  * @returns {object|null} Webhook spec
  */
 async function fetchWebhookSpec(projectRoot) {
-	const config = getEnvironmentConfig();
+	const config = getEnvironmentConfig()
 
 	// Try remote first
-	let spec = await fetchSpec(config.webhookSpec, "Webhook spec");
+	let spec = await fetchSpec(config.webhookSpec, "Webhook spec")
 
 	// Fallback to local
 	if (!spec && projectRoot) {
-		spec = loadLocalSpec(projectRoot, "webhooks.json", "Webhook spec");
+		spec = loadLocalSpec(projectRoot, "webhooks.json", "Webhook spec")
 	}
 
-	return spec;
+	return spec
 }
 
 /**
@@ -184,11 +183,11 @@ async function fetchWebhookSpec(projectRoot) {
  */
 function isCacheValid() {
 	if (!cache.lastFetch) {
-		return false;
+		return false
 	}
 
-	const elapsed = Date.now() - cache.lastFetch;
-	return elapsed < getCacheTTL();
+	const elapsed = Date.now() - cache.lastFetch
+	return elapsed < getCacheTTL()
 }
 
 /**
@@ -200,45 +199,45 @@ function isCacheValid() {
 async function loadSpecs(projectRoot, forceRefresh = false) {
 	// Return cached if valid and not forcing refresh
 	if (!forceRefresh && isCacheValid()) {
-		console.log("📦 Using cached specs");
+		console.log("📦 Using cached specs")
 		return {
 			openApi: cache.openApi,
 			asyncApi: cache.asyncApi,
 			webhooks: cache.webhooks,
-		};
+		}
 	}
 
-	const root = projectRoot || process.cwd();
+	const root = projectRoot || process.cwd()
 
-	console.log("🔄 Loading API specs...");
-	console.log(`   Environment: ${process.env.API_ENV || "production"}`);
+	console.log("🔄 Loading API specs...")
+	console.log(`   Environment: ${process.env.API_ENV || "production"}`)
 
 	// Fetch all specs in parallel
 	const [openApi, asyncApi, webhooks] = await Promise.all([
 		fetchOpenApiSpec(root),
 		fetchAsyncApiSpec(root),
 		fetchWebhookSpec(root),
-	]);
+	])
 
 	// Update cache
-	cache.openApi = openApi;
-	cache.asyncApi = asyncApi;
-	cache.webhooks = webhooks;
-	cache.lastFetch = Date.now();
+	cache.openApi = openApi
+	cache.asyncApi = asyncApi
+	cache.webhooks = webhooks
+	cache.lastFetch = Date.now()
 
 	// Log summary
-	const loaded = [];
-	if (openApi) loaded.push("OpenAPI");
-	if (asyncApi) loaded.push("AsyncAPI");
-	if (webhooks) loaded.push("Webhooks");
+	const loaded = []
+	if (openApi) loaded.push("OpenAPI")
+	if (asyncApi) loaded.push("AsyncAPI")
+	if (webhooks) loaded.push("Webhooks")
 
 	if (loaded.length > 0) {
-		console.log(`✅ Loaded specs: ${loaded.join(", ")}`);
+		console.log(`✅ Loaded specs: ${loaded.join(", ")}`)
 	} else {
-		console.warn("⚠️  No specs were loaded");
+		console.warn("⚠️  No specs were loaded")
 	}
 
-	return { openApi, asyncApi, webhooks };
+	return { openApi, asyncApi, webhooks }
 }
 
 /**
@@ -247,13 +246,13 @@ async function loadSpecs(projectRoot, forceRefresh = false) {
  * @returns {object} Freshly loaded specs
  */
 async function refreshSpecs(projectRoot) {
-	console.log("🔄 Refreshing API specs...");
-	cache.openApi = null;
-	cache.asyncApi = null;
-	cache.webhooks = null;
-	cache.lastFetch = null;
+	console.log("🔄 Refreshing API specs...")
+	cache.openApi = null
+	cache.asyncApi = null
+	cache.webhooks = null
+	cache.lastFetch = null
 
-	return loadSpecs(projectRoot, true);
+	return loadSpecs(projectRoot, true)
 }
 
 /**
@@ -261,8 +260,8 @@ async function refreshSpecs(projectRoot) {
  * @returns {object} Cache status info
  */
 function getCacheStatus() {
-	const ttl = getCacheTTL();
-	const elapsed = cache.lastFetch ? Date.now() - cache.lastFetch : null;
+	const ttl = getCacheTTL()
+	const elapsed = cache.lastFetch ? Date.now() - cache.lastFetch : null
 
 	return {
 		hasOpenApi: !!cache.openApi,
@@ -272,7 +271,7 @@ function getCacheStatus() {
 		cacheValid: isCacheValid(),
 		ttlMs: ttl,
 		expiresIn: elapsed !== null ? Math.max(0, ttl - elapsed) : null,
-	};
+	}
 }
 
 /**
@@ -284,7 +283,7 @@ function getCachedSpecs() {
 		openApi: cache.openApi,
 		asyncApi: cache.asyncApi,
 		webhooks: cache.webhooks,
-	};
+	}
 }
 
 module.exports = {
@@ -297,4 +296,4 @@ module.exports = {
 	getCacheStatus,
 	getCachedSpecs,
 	isCacheValid,
-};
+}

package/runtime/package.json

@@ -0,0 +1,3 @@
+{
+	"type": "module"
+}

package/runtime/server.js

@@ -1,31 +1,31 @@
-const express = require("express");
-const cors = require("cors");
-const fs = require("fs");
-const path = require("path");
-const dotenv = require("dotenv");
+const express = require("express")
+const cors = require("cors")
+const fs = require("fs")
+const path = require("path")
+const dotenv = require("dotenv")
 
 // Load .env file from project directory (process.cwd())
-const envPath = path.join(process.cwd(), ".env");
+const envPath = path.join(process.cwd(), ".env")
 if (fs.existsSync(envPath)) {
-	dotenv.config({ path: envPath });
+	dotenv.config({ path: envPath })
 }
 
-const app = express();
+const app = express()
 
 app.use(
 	cors({
 		origin: "*",
-	})
-);
+	}),
+)
 
 // Middleware to parse JSON
-app.use(express.json());
+app.use(express.json())
 
 // Serve static development assets
-const devAssetsDir = path.join(process.cwd(), "dev-assets");
+const devAssetsDir = path.join(process.cwd(), "dev-assets")
 if (fs.existsSync(devAssetsDir)) {
-	app.use("/dev-assets", express.static(devAssetsDir));
-	console.log("📁 Serving development assets from /dev-assets");
+	app.use("/dev-assets", express.static(devAssetsDir))
+	console.log("📁 Serving development assets from /dev-assets")
 }
 
 /**
@@ -33,92 +33,92 @@ if (fs.existsSync(devAssetsDir)) {
  */
 function findExistingCertificates(certsDir) {
 	if (!fs.existsSync(certsDir)) {
-		return null;
+		return null
 	}
 
-	const files = fs.readdirSync(certsDir);
+	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")
-	);
+			f.startsWith("localhost") && f.endsWith(".pem") && !f.includes("-key"),
+	)
 	const keyFile = files.find(
-		(f) => f.startsWith("localhost") && f.endsWith("-key.pem")
-	);
+		(f) => f.startsWith("localhost") && f.endsWith("-key.pem"),
+	)
 
 	if (certFile && keyFile) {
-		const certPath = path.join(certsDir, certFile);
-		const keyPath = path.join(certsDir, 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);
+			const certStats = fs.statSync(certPath)
+			const keyStats = fs.statSync(keyPath)
 
 			if (certStats.size > 0 && keyStats.size > 0) {
-				return { certPath, keyPath };
+				return { certPath, keyPath }
 			}
 		} catch (error) {
 			// Files don't exist or can't be read
 		}
 	}
 
-	return null;
+	return null
 }
 
 // Check for SSL certificates using improved detection
-const certsDir = path.join(process.cwd(), ".certs");
-const existingCerts = findExistingCertificates(certsDir);
+const certsDir = path.join(process.cwd(), ".certs")
+const existingCerts = findExistingCertificates(certsDir)
 
-let server;
-let protocol = "HTTP";
+let server
+let protocol = "HTTP"
 
 if (existingCerts) {
 	// Use HTTPS if certificates are available
-	const https = require("https");
+	const https = require("https")
 	const options = {
 		cert: fs.readFileSync(existingCerts.certPath),
 		key: fs.readFileSync(existingCerts.keyPath),
-	};
-	server = https.createServer(options, app);
-	protocol = "HTTPS";
-	console.log(`📁 Using certificate: ${path.basename(existingCerts.certPath)}`);
-	console.log(`🔑 Using key: ${path.basename(existingCerts.keyPath)}`);
+	}
+	server = https.createServer(options, app)
+	protocol = "HTTPS"
+	console.log(`📁 Using certificate: ${path.basename(existingCerts.certPath)}`)
+	console.log(`🔑 Using key: ${path.basename(existingCerts.keyPath)}`)
 } else {
 	// Fall back to HTTP if no certificates
-	const http = require("http");
-	server = http.createServer(app);
+	const http = require("http")
+	server = http.createServer(app)
 }
 
-const { Server } = require("socket.io");
+const { Server } = require("socket.io")
 
 const io = new Server(server, {
 	cors: {
 		origin: "*",
 	},
-});
+})
 
 io.on("connection", (socket) => {
 	socket.onAny((event, data) => {
-		socket.broadcast.emit(event, data);
-	});
-});
+		socket.broadcast.emit(event, data)
+	})
+})
 
 // HTTP endpoint for CLI to send socket events
 app.post("/emit", (req, res) => {
-	const { event, channel, data } = req.body;
+	const { event, channel, data } = req.body
 
 	if (!event) {
-		return res.status(400).json({ error: "Event name is required" });
+		return res.status(400).json({ error: "Event name is required" })
 	}
 
-	console.log(`📡 CLI triggered socket event: ${event}`);
-	console.log(`📺 Channel: ${channel}`);
-	console.log(`📦 Data:`, data);
+	console.log(`📡 CLI triggered socket event: ${event}`)
+	console.log(`📺 Channel: ${channel}`)
+	console.log(`📦 Data:`, data)
 
 	// Emit to all connected clients
-	io.emit(event, data);
+	io.emit(event, data)
 
 	res.json({
 		success: true,
@@ -126,8 +126,8 @@ app.post("/emit", (req, res) => {
 		event,
 		channel,
 		data,
-	});
-});
+	})
+})
 
 // Basic health check endpoint
 app.get("/health", (req, res) => {
@@ -136,8 +136,8 @@ app.get("/health", (req, res) => {
 		protocol,
 		mockApiEnabled: process.env.MOCK_API_ENABLED === "true",
 		timestamp: new Date().toISOString(),
-	});
-});
+	})
+})
 
 /**
  * Initialize and start the server
@@ -146,35 +146,35 @@ async function startServer() {
 	// Mount Mock API if enabled
 	if (process.env.MOCK_API_ENABLED === "true") {
 		try {
-			const { createMockApiRouter } = require("./mock-api");
+			const { createMockApiRouter } = require("./mock-api")
 			const mockRouter = await createMockApiRouter(io, {
 				projectRoot: process.cwd(),
-			});
-			app.use(mockRouter);
+			})
+			app.use(mockRouter)
 		} catch (error) {
-			console.error("❌ Failed to initialize Mock API:", error.message);
-			console.log("   Continuing without Mock API...");
+			console.error("❌ Failed to initialize Mock API:", error.message)
+			console.log("   Continuing without Mock API...")
 		}
 	}
 
-	const socketIoPort = process.env.SOCKET_IO_PORT || 3069;
+	const socketIoPort = process.env.SOCKET_IO_PORT || 3069
 
 	server.listen(socketIoPort, () => {
 		console.log(
-			`\n🔗 Socket.IO server running on ${protocol} at port ${socketIoPort}`
-		);
+			`\n🔗 Socket.IO server running on ${protocol} at port ${socketIoPort}`,
+		)
 		if (protocol === "HTTPS") {
-			console.log("🔒 Using SSL certificates for secure WebSocket connections");
+			console.log("🔒 Using SSL certificates for secure WebSocket connections")
 		}
-		console.log("📡 Socket event simulation available at POST /emit");
+		console.log("📡 Socket event simulation available at POST /emit")
 		if (process.env.MOCK_API_ENABLED === "true") {
-			console.log("🎭 Mock API enabled - routes available under /api/*");
+			console.log("🎭 Mock API enabled - routes available under /api/*")
 		}
-	});
+	})
 }
 
 // Start the server
 startServer().catch((error) => {
-	console.error("Failed to start server:", error);
-	process.exit(1);
-});
+	console.error("Failed to start server:", error)
+	process.exit(1)
+})