wirejs-scripts 3.0.103 → 3.0.105-payments

package/bin.js

@@ -3,8 +3,10 @@
 import process from 'process';
 import { execSync, spawn } from 'child_process';
 import http from 'http';
-import fs, { watch } from 'fs';
+import fs from 'fs';
+import os from 'os';
 import path from 'path';
+import { fileURLToPath } from 'url';
 
 import webpack from 'webpack';
 import webpackConfigure from './configs/webpack.config.js';
@@ -14,14 +16,29 @@ import { contentType } from 'mime-types';
 
 import { JSDOM } from 'jsdom';
 import { useJSDOM } from 'wirejs-dom/v2';
-import { requiresContext, Context, CookieJar } from 'wirejs-resources';
+import {
+	requiresContext,
+	Context,
+	CookieJar,
+	Endpoint,
+	SystemAttribute,
+} from 'wirejs-resources';
 import { prebuildApi } from 'wirejs-resources/internal';
 
+import * as DefaultGateway from 'default-gateway';
+import * as NatPmp from 'nat-pmp';
+
 const CWD = process.cwd();
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 const getWebpackConfig = () => webpackConfigure(process.env, process.argv);
 const [_nodeBinPath, _scriptPath, action, ...actionArgs] = process.argv;
 const [subAction] = actionArgs;
 const processes = [];
+let publicIp = null;
+let networkIp = null;
+let httpPort = 3000;
+let wsPort = 3001;
 
 const logger = {
 	log(...items) {
@@ -44,24 +61,169 @@ globalThis.fetch = (url, ...args) => {
 		try {
 			return fetch(new URL(url), ...args);
 		} catch {
-			return fetch(`http://localhost:3000${url}`, ...args);
+			return fetch(`http://localhost:${httpPort}${url}`, ...args);
 		}
 	} else {
 		return oldFetch(url, ...args);
 	}
 }
 
+function isWSL() {
+	if (os.platform() !== 'linux') return false;
+	if (process.env.WSL_DISTRO_NAME) return true;
+	try {
+		const version = fs.readFileSync('/proc/version', 'utf-8').toLowerCase();
+		return version.includes('microsoft');
+	} catch {
+		return false;
+	}
+}
+
+function getLocalIPv4() {
+	if (isWSL()) {
+		try {
+			const $ = "\\$";
+			const command = `powershell.exe -Command "& { (Get-NetIPAddress -AddressFamily IPv4 | Where-Object { ${$}_.InterfaceAlias -notlike '*WSL*' -and ${$}_.IPAddress -notlike '169.*' } | Select-Object -First 1 -ExpandProperty IPAddress) }"`;
+			const output = execSync(command, { cwd: CWD, encoding: 'utf8' }).toString().trim();
+			return output || null;
+		} catch (err) {
+			console.error("❌ Failed to get Windows IPv4 from WSL:", err);
+			return null;
+		}
+	} else {
+		const interfaces = os.networkInterfaces();
+		for (const name of Object.keys(interfaces)) {
+			for (const iface of interfaces[name]) {
+				if (iface.family === 'IPv4' && !iface.internal) {
+					return iface.address;
+				}
+			}
+		}
+		return null;
+	}
+}
+
+/**
+ * For Windows Subsystem for Linux (WSL) environments, get the IP address
+ * Windows has assigned to the Linux container.
+ * 
+ * @returns 
+ */
+function getWSLIP() {
+	const output = execSync('hostname -I').toString().trim();
+	return output.split(' ')[0];
+}
+
+async function getGateway() {
+	if (isWSL()) {
+		const probeCommand = [
+			'powershell.exe -Command',
+			`"Get-NetRoute -DestinationPrefix '0.0.0.0/0'`,
+			`| Sort-Object RouteMetric`,
+			`| Select-Object -First 1 -ExpandProperty NextHop"`,
+		].join(' ');
+		return execSync(probeCommand).toString().replace(/\r/, '').trim();
+	} else {
+		return (await DefaultGateway.gateway4async()).gateway;
+	}
+}
+
+function portProxyRuleExists(listenPort, wslIp, wslPort) {
+	try {
+		const output = execSync(`netsh interface portproxy show all`, {
+			shell: 'powershell.exe'
+		}).toString();
+
+		const regex = new RegExp(
+			`0\\.0\\.0\\.0\\s+${listenPort}\\s+${wslIp.replace(/\./g, '\\.')}\\s+${wslPort}`
+		);
+
+		return regex.test(output);
+	} catch {
+		return false;
+	}
+}
+
+function firewallRuleExists(port) {
+	try {
+		const command = `powershell.exe -Command "Get-NetFirewallRule -DisplayName 'WSLForward${port}'"`;
+    	const result = execSync(command).toString().trim();
+		return result.length > 0;
+	} catch (err) {
+		return false;
+	}
+}
+
+async function startForwardingWSLPort(wslPort = httpPort, publicPort = httpPort) {
+	if (!isWSL()) throw new Error("Not running in WSL.");
+
+	const wslIP = getWSLIP();
+	console.log(`▶ Spawning Windows-side forward: :${publicPort} → ${wslIP}:${wslPort}`);
+
+	if (!portProxyRuleExists(publicPort, wslIP, wslPort)) {
+		const forwardPortCommand = [
+			'Start-Process',
+			'netsh',
+			'-Verb RunAs',
+			'-ArgumentList',
+			`'interface portproxy add v4tov4 `,
+			`listenport=${publicPort} listenaddress=0.0.0.0`,
+			`connectport=${wslPort} connectaddress=${wslIP}'`
+		].join(' ');
+		execSync(`powershell.exe -Command "${forwardPortCommand}"`);
+	}
+
+	if (!firewallRuleExists(publicPort)) {
+		const openFirewallCommand = [
+			'Start-Process',
+			'powershell',
+			'-Verb',
+			'RunAs',
+			'-ArgumentList',
+			`'-Command "New-NetFirewallRule -DisplayName WSLForward${publicPort} -Direction Inbound -LocalPort ${publicPort} -Protocol TCP -Action Allow"'`
+		].join(' ');
+		execSync(`powershell.exe -Command "${openFirewallCommand}"`);
+	}
+}
+
 /**
  * 
  * @param {http.IncomingMessage} req 
  * @returns 
  */
-function createContext(req) {
-	const { url, headers } = req;
+async function createContext(req) {
+	const { url, headers, method } = req;
+	const body = method.toLowerCase() === 'post'
+		? (await postData(req))
+		: undefined;
 	const origin = headers.origin || `http://${headers.host}`;
 	const location = new URL(`${origin}${url}`);
 	const cookies = new CookieJar(headers.cookie);
-	return new Context({ cookies, location });
+	return new Context({
+		cookies,
+		location,
+		httpMethod: method,
+		requestHeaders: headers,
+		requestBody: body,
+		runtimeAttributes: [
+			new SystemAttribute('wirejs', 'deployment-type', {
+				description: 'Deployment under which your system is running.',
+				value: 'dev'
+			}),
+			new SystemAttribute('wirejs', 'http-origin-local', {
+				description: 'HTTP origin (base address) to use for local development.',
+				value: `http://localhost:${httpPort}`,
+			}),
+			new SystemAttribute('wirejs', 'http-origin-network', {
+				description: 'HTTP origin (base address) for machines on your network to use.',
+				value: `http://${networkIp}:${httpPort}`,
+			}),
+			new SystemAttribute('wirejs', 'http-origin-public', {
+				description: 'HTTP origin (base address) for machines outside your network to use. Only populated for `npm run start:public`, and only accessible in environments that support NAT-PMP.',
+				value: publicIp ? `http://${publicIp}:${httpPort}` : null,
+			}),
+		]
+	});
 }
 
 /**
@@ -101,20 +263,15 @@ async function callApiMethod(api, call, context) {
 
 /**
  * 
- * @param {http.IncomingMessage} req 
+ * @param {Context} context
  * @param {http.ServerResponse} res 
  * @returns 
  */
-async function handleApiResponse(req, res) {
-	const {
-		headers, url, method, params, query,
-		baseUrl, originalUrl, trailers
-	} = req;
-
-	const context = createContext(req);
+async function handleApiResponse(context, res) {
+	const url = context.location.pathname;
 
 	if (url === '/api') {
-		const body = await postData(req);
+		const body = context.requestBody;
 		const calls = JSON.parse(body);
 		logger.info('handling API request', body);
 
@@ -141,7 +298,9 @@ async function handleApiResponse(req, res) {
 			);
 		}
 
-		res.setHeader('Content-Type', 'application/json; charset=utf-8')
+		res.setHeader('Content-Type', 'application/json; charset=utf-8');
+		// internal API isn't allowed to set individual response headers, codes, etc.
+		// because they may be batched.
 		res.end(JSON.stringify(
 			responses
 		));
@@ -155,23 +314,56 @@ async function handleApiResponse(req, res) {
 
 /**
  * 
- * @param {http.IncomingMessage} req 
+ * @param {Context} context
+ * @param {http.ServerResponse} res 
+ * @returns 
+ */
+async function tryEndpointPath(context, res) {
+	/**
+	 * @type Endpoint
+	 */
+	let matchingEndpoint = undefined;
+
+	try {
+		const apiPath = path.join(CWD, 'api', 'dist', 'index.js');
+		await import(`${apiPath}?cache-id=${new Date().getTime()}`);
+		const allHandlers = [...Endpoint.list()];
+		const matchingHandlers = allHandlers
+			.filter(e => globMatch(e.path, context.location.pathname));
+		matchingEndpoint = matchingHandlers.sort(byLength).pop();
+	} catch (error) {
+		return;
+	}
+
+	if (!matchingEndpoint) return;
+
+	const response = await matchingEndpoint.handle(context)
+	setResponseDetailsFromContext(context, res);
+	res.end(response);
+	return true;
+}
+
+/**
+ * 
+ * @param {Context} context 
  * @returns 
  */
-function fullPathFrom(req) {
-	const relativePath = req.url === '/' ? 'index.html' : req.url;
+function fullPathFrom(context) {
+	const relativePath = context.location.pathname === '/'
+		? 'index.html'
+		: context.location.pathname;
 	return path.join(CWD, 'dist', relativePath);
 }
 
 
 /**
  * 
- * @param {http.IncomingMessage} req 
+ * @param {Context} context
  * @param {http.ServerResponse} res 
  * @returns 
  */
-async function tryStaticPath(req, res) {
-	const fullPath = fullPathFrom(req);
+async function tryStaticPath(context, res) {
+	const fullPath = fullPathFrom(context);
 
 	logger.info('checking static', fullPath);
 	if (!fs.existsSync(fullPath)) return false;
@@ -250,12 +442,11 @@ function routeSSR(context, forceExt) {
 }
 
 /**
- * @param {http.IncomingMessage} req 
+ * @param {Context} context
  * @param {http.ServerResponse} res 
  * @returns 
  */
-async function trySSRScriptPath(req, res) {
-	const context = createContext(req);
+async function trySSRScriptPath(context, res) {
 	const srcPath = routeSSR(context);
 	if (!srcPath) return false;
 
@@ -275,13 +466,26 @@ async function trySSRScriptPath(req, res) {
 
 /**
  * 
- * @param {http.IncomingMessage} req
+ * @param {Context} context 
+ * @param {http.ServerResponse} res 
+ */
+function setResponseDetailsFromContext(context, res) {
+	for (const [k, v] of Object.entries(context.responseHeaders)) {
+		res.setHeader(k, v);
+	}
+	if (context.locationIsDirty) {
+		res.setHeader('Location', context.location.href);
+	}
+	if (context.responseCode) res.statusCode = context.responseCode;
+}
+
+/**
+ * 
+ * @param {Context} context
  * @param {http.ServerResponse} res
  * @returns 
  */
-async function trySSRPath(req, res) {
-	const context = createContext(req);
-
+async function trySSRPath(context, res) {
 	const asJSPath = context.location.pathname.replace(/\.(\w+)$/, '') + '.js';
 	const srcPath = routeSSR(context, 'js');
 	if (!srcPath) return false;
@@ -300,6 +504,7 @@ async function trySSRPath(req, res) {
 				res.setHeader('Content-Type', contentType(
 					context.location.pathname.split('.').pop()
 				));
+				setResponseDetailsFromContext(context, res);
 				res.end(doc);
 			} else {
 				const doctype = doc.parentNode.doctype?.name || '';
@@ -316,7 +521,8 @@ async function trySSRPath(req, res) {
 					doc.parentNode.body.appendChild(script);
 				}
 
-				res.setHeader('Content-type', 'text/html; charset=utf-8');
+				res.setHeader('Content-Type', 'text/html; charset=utf-8');
+				setResponseDetailsFromContext(context, res);
 				res.end([
 					doctype ? `<!doctype ${doctype}>\n` : '',
 					doc.outerHTML
@@ -345,16 +551,16 @@ async function trySSRPath(req, res) {
  */
 async function handleRequest(req, res, compiler) {
 	logger.info('received', JSON.stringify({ url: req.url }, null, 2));
+	const context = await createContext(req);
 
 	if (req.url.startsWith('/api')) {
-		return handleApiResponse(req, res, compiler);
+		return handleApiResponse(context, res, compiler);
 	}
 
-	// const fs = compiler.outputFileSystem;
-
-	if (await tryStaticPath(req, res, fs)) return;
-	if (await trySSRScriptPath(req, res, fs)) return;
-	if (await trySSRPath(req, res, fs)) return;
+	if (await tryStaticPath(context, res, fs)) return;
+	if (await trySSRScriptPath(context, res, fs)) return;
+	if (await trySSRPath(context, res, fs)) return;
+	if (await tryEndpointPath(context, res, fs)) return;
 
 	// if we've made it this far, we don't have what you're looking for
 	res.statusCode = '404';
@@ -391,7 +597,7 @@ async function compile(watch = false) {
 				outdir: path.join(apiDir, 'dist'),
 				platform: 'node',
 				bundle: true,
-				external: ['./node_modules/*'],
+				packages: 'external',
 				format: 'esm',
 				plugins: [{
 					name: 'post-build-rebuild-api-client',
@@ -413,21 +619,51 @@ async function compile(watch = false) {
 			await prebuild.rebuild();
 			prebuild.watch();
 
+			if (actionArgs.includes('--public') || actionArgs.includes('-p')) {
+				console.log("Attempting to open external port.");
+				const gatewayIp = await getGateway();
+				const natPmpClient = NatPmp.connect(gatewayIp);
+				natPmpClient.externalIp((err, info) => {
+					if (err) throw err;
+					const ip = info.ip.join('.');
+					console.log(`Found external address: ${ip} ... trying to connect.`);
+					for (const port of [httpPort, wsPort]) {
+						natPmpClient.portMapping({
+							private: port,
+							public: port,
+							ttl: 3600,
+						}, (err, info) => {
+							if (err) throw err;
+							console.log(`Listening externally at ${ip}:${port}`);
+							publicIp = ip
+						});
+					};
+				});
+				if (isWSL()) startForwardingWSLPort();
+			}
+
 			webpack({
 				...getWebpackConfig(),
 				mode: 'development',
 				watch: true
 			}, () => {
 				console.log();
-				console.log('Compiled: http://localhost:3000/');
+				console.log('Compiled.\n');
+				console.log(`Local\nhttp://localhost:${httpPort}/\n`);
+				networkIp = getLocalIPv4();
+				if (networkIp) {
+					console.log(`Network\nhttp://${networkIp}:${httpPort}/\n`)
+				}
+				if (publicIp) {
+					console.log(`Public\nhttp://${publicIp}:${httpPort}/\n`);
+				}
 			}).run(() => { });
 
 			logger.log('Starting server...');
 			const server = http.createServer(handleRequest);
-			server.listen(3000).on('listening', () => {
-				console.log('Started listening on http://localhost:3000/')
+			server.listen(httpPort).on('listening', () => {
+				console.log(`Started listening on port ${httpPort}`);
 			});
-
 		} else {
 			logger.log('prebundling JS');
 			await esbuild.build({

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wirejs-scripts",
-	"version": "3.0.103",
+	"version": "3.0.105-payments",
 	"description": "Basic build and start commands for wirejs apps",
 	"type": "module",
 	"bin": {
@@ -24,17 +24,19 @@
 	"dependencies": {
 		"copy-webpack-plugin": "^10.2.4",
 		"css-loader": "^5.2.0",
+		"default-gateway": "^7.2.2",
 		"esbuild": "^0.24.2",
 		"file-loader": "^6.2.0",
 		"glob": "^7.2.0",
 		"jsdom": "^25.0.1",
 		"marked": "^2.0.1",
 		"mime-types": "^2.1.35",
+		"nat-pmp": "^1.0.0",
 		"raw-loader": "^4.0.2",
 		"rimraf": "^6.0.1",
 		"style-loader": "^2.0.0",
 		"webpack": "^5.97.1",
-		"wirejs-dom": "^1.0.41",
-		"wirejs-resources": "^0.1.105"
+		"wirejs-dom": "^1.0.42",
+		"wirejs-resources": "^0.1.107-payments"
 	}
 }