@php-wasm/cli 0.1.0 → 0.1.1

package/.eslintrc.json

@@ -0,0 +1,18 @@
+{
+	"extends": ["../../../.eslintrc.json"],
+	"ignorePatterns": ["!**/*"],
+	"overrides": [
+		{
+			"files": ["*.ts", "*.tsx", "*.js", "*.jsx"],
+			"rules": {}
+		},
+		{
+			"files": ["*.ts", "*.tsx"],
+			"rules": {}
+		},
+		{
+			"files": ["*.js", "*.jsx"],
+			"rules": {}
+		}
+	]
+}

package/README.md

@@ -0,0 +1,11 @@
+# php-wasm-cli
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build php-wasm-cli` to build the library.
+
+## Running unit tests
+
+Run `nx test php-wasm-cli` to execute the unit tests via [Jest](https://jestjs.io).

package/jest.config.ts

@@ -0,0 +1,13 @@
+/* eslint-disable */
+export default {
+	displayName: 'nx-extensions',
+	preset: '../../../jest.preset.js',
+	transform: {
+		'^.+\\.[tj]s$': [
+			'ts-jest',
+			{ tsconfig: '<rootDir>/tsconfig.spec.json' },
+		],
+	},
+	moduleFileExtensions: ['ts', 'js', 'html'],
+	coverageDirectory: '../../../coverage/packages/nx-extensions',
+};

package/package.json

@@ -1,27 +1,23 @@
 {
-  "name": "@php-wasm/cli",
-  "version": "0.1.0",
-  "description": "PHP.wasm CLI for node.js",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/WordPress/wordpress-playground"
-  },
-  "homepage": "https://developer.wordpress.org/playground",
-  "author": "The WordPress contributors",
-  "contributors": [
-    {
-      "name": "Adam Zielinski",
-      "email": "adam@adamziel.com",
-      "url": "https://github.com/adamziel"
-    }
-  ],
-  "license": "GPL-2.0-or-later",
-  "type": "module",
-  "main": "main.js",
-  "bin": "cli.js",
-  "dependencies": {
-    "comlink": "4.4.1",
-    "ws": "8.13.0",
-    "@php-wasm/node": "0.1.0"
-  }
+	"name": "@php-wasm/cli",
+	"version": "0.1.1",
+	"description": "PHP.wasm CLI for node.js",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/WordPress/wordpress-playground"
+	},
+	"homepage": "https://developer.wordpress.org/playground",
+	"author": "The WordPress contributors",
+	"contributors": [
+		{
+			"name": "Adam Zielinski",
+			"email": "adam@adamziel.com",
+			"url": "https://github.com/adamziel"
+		}
+	],
+	"license": "GPL-2.0-or-later",
+	"type": "module",
+	"main": "main.js",
+	"bin": "cli.js",
+	"gitHead": "eb0404cb59d670e4c0eb769021e510412b6232e9"
 }

package/project.json

@@ -0,0 +1,78 @@
+{
+	"name": "php-wasm-cli",
+	"$schema": "../../../node_modules/nx/schemas/project-schema.json",
+	"sourceRoot": "packages/php-wasm/cli/src",
+	"projectType": "library",
+	"targets": {
+		"build": {
+			"executor": "@wp-playground/nx-extensions:package-json",
+			"options": {
+				"tsConfig": "packages/php-wasm/cli/tsconfig.lib.json",
+				"outputPath": "dist/packages/php-wasm/cli",
+				"buildTarget": "php-wasm-cli:build:bundle:production"
+			}
+		},
+		"build:bundle": {
+			"executor": "@nrwl/vite:build",
+			"outputs": ["{options.outputPath}"],
+			"options": {
+				"main": "dist/packages/php-wasm/cli/main.js",
+				"outputPath": "dist/packages/php-wasm/cli"
+			},
+			"defaultConfiguration": "production",
+			"configurations": {
+				"development": {
+					"minify": false
+				},
+				"production": {
+					"minify": true
+				}
+			}
+		},
+		"start": {
+			"executor": "@wp-playground/nx-extensions:built-script",
+			"options": {
+				"scriptPath": "dist/packages/php-wasm/cli/main.js"
+			},
+			"dependsOn": ["build", "^build-for-cli-run"]
+		},
+		"publish": {
+			"executor": "nx:run-commands",
+			"options": {
+				"command": "node tools/scripts/publish.mjs php-wasm-cli {args.ver} {args.tag}"
+			},
+			"dependsOn": ["build"]
+		},
+		"lint": {
+			"executor": "@nrwl/linter:eslint",
+			"outputs": ["{options.outputFile}"],
+			"options": {
+				"lintFilePatterns": ["packages/php-wasm/cli/**/*.ts"]
+			}
+		},
+		"test": {
+			"executor": "@nrwl/jest:jest",
+			"outputs": ["{workspaceRoot}/coverage/{projectRoot}"],
+			"options": {
+				"jestConfig": "packages/php-wasm/cli/jest.config.ts",
+				"passWithNoTests": true
+			},
+			"configurations": {
+				"ci": {
+					"ci": true,
+					"codeCoverage": true
+				}
+			}
+		},
+		"typecheck": {
+			"executor": "@nrwl/workspace:run-commands",
+			"options": {
+				"commands": [
+					"yarn tsc -p packages/php-wasm/cli/tsconfig.lib.json --noEmit",
+					"yarn tsc -p packages/php-wasm/cli/tsconfig.spec.json --noEmit"
+				]
+			}
+		}
+	},
+	"tags": ["scope:php-wasm-public"]
+}

package/src/lib/inbound-tcp-to-ws-proxy.ts

@@ -0,0 +1,89 @@
+import { createServer } from 'net';
+import { WebSocketServer, WebSocket } from 'ws';
+import { debugLog } from './utils.js';
+function log(...args: any[]) {
+	debugLog('[TCP Server]', ...args);
+}
+
+export function addTCPServerToWebSocketServerClass(
+	wsListenPort: number,
+	WSServer: typeof WebSocketServer
+): any {
+	return class PHPWasmWebSocketServer extends WSServer {
+		constructor(options: any, callback: any) {
+			const requestedPort = options.port;
+			options.port = wsListenPort;
+			listenTCPToWSProxy({
+				tcpListenPort: requestedPort,
+				wsConnectPort: wsListenPort,
+			});
+			super(options, callback);
+		}
+	};
+}
+
+export interface InboundTcpToWsProxyOptions {
+	tcpListenPort: number;
+	wsConnectHost?: string;
+	wsConnectPort: number;
+}
+export function listenTCPToWSProxy(options: InboundTcpToWsProxyOptions) {
+	options = {
+		wsConnectHost: '127.0.0.1',
+		...options,
+	};
+	const { tcpListenPort, wsConnectHost, wsConnectPort } = options;
+	const server = createServer();
+	server.on('connection', function handleConnection(tcpSource) {
+		const inBuffer: Buffer[] = [];
+
+		const wsTarget = new WebSocket(
+			`ws://${wsConnectHost}:${wsConnectPort}/`
+		);
+		wsTarget.binaryType = 'arraybuffer';
+		function wsSend(data: Buffer) {
+			wsTarget.send(new Uint8Array(data));
+		}
+
+		wsTarget.addEventListener('open', function () {
+			log('Outbound WebSocket connection established');
+			while (inBuffer.length > 0) {
+				wsSend(inBuffer.shift()!);
+			}
+		});
+		wsTarget.addEventListener('message', (e) => {
+			log(
+				'WS->TCP message:',
+				new TextDecoder().decode(e.data as ArrayBuffer)
+			);
+			tcpSource.write(Buffer.from(e.data as ArrayBuffer));
+		});
+		wsTarget.addEventListener('close', () => {
+			log('WebSocket connection closed');
+			tcpSource.end();
+		});
+
+		tcpSource.on('data', function (data) {
+			log('TCP->WS message:', data);
+			if (wsTarget.readyState === WebSocket.OPEN) {
+				while (inBuffer.length > 0) {
+					wsSend(inBuffer.shift()!);
+				}
+				wsSend(data);
+			} else {
+				inBuffer.push(data);
+			}
+		});
+		tcpSource.once('close', function () {
+			log('TCP connection closed');
+			wsTarget.close();
+		});
+		tcpSource.on('error', function () {
+			log('TCP connection error');
+			wsTarget.close();
+		});
+	});
+	server.listen(tcpListenPort, function () {
+		log('TCP server listening');
+	});
+}

package/src/lib/outbound-ws-to-tcp-proxy.ts

@@ -0,0 +1,231 @@
+/**
+ * This is a simple TCP proxy server that allows PHP to connect to a remote
+ * server via WebSockets. This is necessary because WebAssembly has no access
+ * to the network.
+ *
+ * This module was forked from the @maximegris/node-websockify npm package.
+ */
+'use strict';
+
+import * as dns from 'dns';
+import * as util from 'util';
+import * as net from 'net';
+import * as http from 'http';
+import { WebSocketServer } from 'ws';
+import { debugLog } from './utils.js';
+
+function log(...args: any[]) {
+	debugLog('[WS Server]', ...args);
+}
+
+const lookup = util.promisify(dns.lookup);
+
+function prependByte(
+	chunk: string | ArrayBuffer | ArrayLike<number>,
+	byte: number
+) {
+	if (typeof chunk === 'string') {
+		chunk = String.fromCharCode(byte) + chunk;
+	} else if (chunk instanceof ArrayBuffer) {
+		const buffer = new Uint8Array(chunk.byteLength + 1);
+		buffer[0] = byte;
+		buffer.set(new Uint8Array(chunk), 1);
+		chunk = buffer.buffer;
+	} else {
+		throw new Error('Unsupported chunk type');
+	}
+	return chunk;
+}
+
+/**
+ * Send a chunk of data to the remote server.
+ */
+export const COMMAND_CHUNK = 0x01;
+/**
+ * Set a TCP socket option.
+ */
+export const COMMAND_SET_SOCKETOPT = 0x02;
+
+/**
+ * Adds support for TCP socket options to WebSocket class.
+ *
+ * Socket options are implemented by adopting a specific data transmission
+ * protocol between WS client and WS server The first byte
+ * of every message is a command type, and the remaining bytes
+ * are the actual data.
+ *
+ * @param  WebSocketConstructor
+ * @returns Decorated constructor
+ */
+export function addSocketOptionsSupportToWebSocketClass(
+	WebSocketConstructor: typeof WebSocket
+) {
+	return class PHPWasmWebSocketConstructor extends WebSocketConstructor {
+		override CONNECTING = 0;
+		override OPEN = 1;
+		override CLOSING = 2;
+		override CLOSED = 3;
+
+		// @ts-ignore
+		send(chunk: any, callback: any) {
+			return this.sendCommand(COMMAND_CHUNK, chunk, callback);
+		}
+
+		setSocketOpt(
+			optionClass: number,
+			optionName: number,
+			optionValue: number
+		) {
+			return this.sendCommand(
+				COMMAND_SET_SOCKETOPT,
+				new Uint8Array([optionClass, optionName, optionValue]).buffer,
+				() => undefined
+			);
+		}
+		sendCommand(
+			commandType: number,
+			chunk: string | ArrayBuffer | ArrayLike<number>,
+			callback: any
+		) {
+			return (WebSocketConstructor.prototype.send as any).call(
+				this,
+				prependByte(chunk, commandType),
+				callback
+			);
+		}
+	};
+}
+
+export function initOutboundWebsocketProxyServer(
+	listenPort: number,
+	listenHost = '127.0.0.1'
+): Promise<http.Server> {
+	log(`Binding the WebSockets server to ${listenHost}:${listenPort}...`);
+	const webServer = http.createServer((request, response) => {
+		response.writeHead(403, { 'Content-Type': 'text/plain' });
+		response.write(
+			'403 Permission Denied\nOnly websockets are allowed here.\n'
+		);
+		response.end();
+	});
+	return new Promise((resolve) => {
+		webServer.listen(listenPort, listenHost, function () {
+			const wsServer = new WebSocketServer({ server: webServer });
+			wsServer.on('connection', onWsConnect);
+			resolve(webServer);
+		});
+	});
+}
+
+// Handle new WebSocket client
+async function onWsConnect(client: any, request: http.IncomingMessage) {
+	const clientAddr = client._socket.remoteAddress;
+	const clientLog = function (...args: any[]) {
+		log(' ' + clientAddr + ': ', ...args);
+	};
+
+	clientLog(
+		'WebSocket connection from : ' +
+			clientAddr +
+			' at URL ' +
+			(request ? request.url : client.upgradeReq.url)
+	);
+	clientLog(
+		'Version ' +
+			client.protocolVersion +
+			', subprotocol: ' +
+			client.protocol
+	);
+
+	// Parse the search params (the host doesn't matter):
+	const reqUrl = new URL(`ws://0.0.0.0` + request.url);
+	const reqTargetPort = Number(reqUrl.searchParams.get('port'));
+	const reqTargetHost = reqUrl.searchParams.get('host');
+	if (!reqTargetPort || !reqTargetHost) {
+		clientLog('Missing host or port information');
+		client.close(3000);
+		return;
+	}
+
+	// eslint-disable-next-line prefer-const
+	let target: any;
+	const recvQueue: Buffer[] = [];
+	function flushMessagesQueue() {
+		while (recvQueue.length > 0) {
+			const msg = recvQueue.pop()! as Buffer;
+			const commandType = msg[0];
+			clientLog('flushing', { commandType }, msg);
+			if (commandType === COMMAND_CHUNK) {
+				target.write(msg.slice(1));
+			} else if (commandType === COMMAND_SET_SOCKETOPT) {
+				const SOL_SOCKET = 1;
+				const SO_KEEPALIVE = 9;
+
+				const IPPROTO_TCP = 6;
+				const TCP_NODELAY = 1;
+				if (msg[1] === SOL_SOCKET && msg[2] === SO_KEEPALIVE) {
+					target.setKeepAlive(msg[3]);
+				} else if (msg[1] === IPPROTO_TCP && msg[2] === TCP_NODELAY) {
+					target.setNoDelay(msg[3]);
+				}
+			} else {
+				clientLog('Unknown command type: ' + commandType);
+				process.exit();
+			}
+		}
+	}
+
+	client.on('message', function (msg: Buffer) {
+		// clientLog('PHP -> network buffer:', msg);
+		recvQueue.unshift(msg);
+		if (target) {
+			flushMessagesQueue();
+		}
+	});
+	client.on('close', function (code: any, reason: any) {
+		clientLog(
+			'WebSocket client disconnected: ' + code + ' [' + reason + ']'
+		);
+		target.end();
+	} as any);
+	client.on('error', function (a: string | Buffer) {
+		clientLog('WebSocket client error: ' + a);
+		target.end();
+	});
+
+	// Resolve the target host to an IP address if it isn't one already
+	let reqTargetIp;
+	if (net.isIP(reqTargetHost) === 0) {
+		clientLog('resolving ' + reqTargetHost + '... ');
+		const resolution = await lookup(reqTargetHost);
+		reqTargetIp = resolution.address;
+		clientLog('resolved ' + reqTargetHost + ' -> ' + reqTargetIp);
+	} else {
+		reqTargetIp = reqTargetHost;
+	}
+	clientLog(
+		'Opening a socket connection to ' + reqTargetIp + ':' + reqTargetPort
+	);
+	target = net.createConnection(reqTargetPort, reqTargetIp, function () {
+		clientLog('Connected to target');
+		flushMessagesQueue();
+	});
+	target.on('data', function (data: any) {
+		// clientLog('network -> PHP buffer:', [...data.slice(0, 100)].join(', ') + '...');
+		try {
+			client.send(data);
+		} catch (e) {
+			clientLog('Client closed, cleaning up target');
+			target.end();
+		}
+	});
+	target.on('end', function () {
+		clientLog('target disconnected');
+		client.close();
+	});
+	target.on('error', function (e: any) {
+		clientLog('target connection error', e);
+		target.end();
+		client.close(3000);
+	});
+}

package/src/lib/utils.ts

@@ -0,0 +1,33 @@
+import * as net from 'net';
+
+export function debugLog(...args: any[]) {
+	if (process.env['DEV']) {
+		console.log(...args);
+	}
+}
+
+export async function findFreePorts(n: number) {
+	const serversPromises: Promise<net.Server>[] = [];
+	for (let i = 0; i < n; i++) {
+		serversPromises.push(listenOnRandomPort());
+	}
+
+	const servers = await Promise.all(serversPromises);
+	const ports: number[] = [];
+	for (const server of servers) {
+		const address = server.address()! as net.AddressInfo;
+		ports.push(address.port);
+		server.close();
+	}
+
+	return ports;
+}
+
+function listenOnRandomPort(): Promise<net.Server> {
+	return new Promise((resolve) => {
+		const server = net.createServer();
+		server.listen(0, () => {
+			resolve(server);
+		});
+	});
+}

package/src/main.ts

@@ -0,0 +1,74 @@
+/**
+ * A CLI script that runs PHP CLI via the WebAssembly build.
+ */
+import { writeFileSync, existsSync } from 'fs';
+import { rootCertificates } from 'tls';
+
+import {
+	initOutboundWebsocketProxyServer,
+	addSocketOptionsSupportToWebSocketClass,
+} from './lib/outbound-ws-to-tcp-proxy.js';
+import { addTCPServerToWebSocketServerClass } from './lib/inbound-tcp-to-ws-proxy.js';
+import { findFreePorts } from './lib/utils.js';
+import { PHP, loadPHPRuntime, getPHPLoaderModule } from '@php-wasm/node';
+
+let args = process.argv.slice(2);
+if (!args.length) {
+	args = ['--help'];
+}
+
+// Write the ca-bundle.crt file to disk so that PHP can find it.
+const caBundlePath = new URL('ca-bundle.crt', (import.meta || {}).url).pathname;
+if (!existsSync(caBundlePath)) {
+	writeFileSync(caBundlePath, rootCertificates.join('\n'));
+}
+
+async function main() {
+	// @ts-ignore
+	const defaultPhpIniPath = await import('./lib/php.ini');
+
+	const phpVersion = process.env['PHP'] || '8.2';
+
+	const [inboundProxyWsServerPort, outboundProxyWsServerPort] =
+		await findFreePorts(2);
+
+	await initOutboundWebsocketProxyServer(outboundProxyWsServerPort);
+
+	// This dynamic import only works after the build step
+	// when the PHP files are present in the same directory
+	// as this script.
+	const phpLoaderModule = await getPHPLoaderModule(phpVersion);
+	const loaderId = await loadPHPRuntime(phpLoaderModule, {
+		ENV: {
+			...process.env,
+			TERM: 'xterm',
+		},
+		websocket: {
+			url: (_: any, host: string, port: string) => {
+				const query = new URLSearchParams({ host, port }).toString();
+				return `ws://127.0.0.1:${outboundProxyWsServerPort}/?${query}`;
+			},
+			subprotocol: 'binary',
+			decorator: addSocketOptionsSupportToWebSocketClass,
+			serverDecorator: addTCPServerToWebSocketServerClass.bind(
+				null,
+				inboundProxyWsServerPort
+			),
+		},
+	});
+	const hasMinusCOption = args.some((arg) => arg.startsWith('-c'));
+	if (!hasMinusCOption) {
+		args.unshift('-c', defaultPhpIniPath);
+	}
+	const php = new PHP(loaderId);
+	php.writeFile(caBundlePath, rootCertificates.join('\n'));
+	args.unshift('-d', `openssl.cafile=${caBundlePath}`);
+	php.cli(['php', ...args]).catch((result) => {
+		if (result.name === 'ExitStatus') {
+			process.exit(result.status === undefined ? 1 : result.status);
+		}
+		throw result;
+	});
+}
+
+main();

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+	"extends": "../../../tsconfig.base.json",
+	"compilerOptions": {
+		"forceConsistentCasingInFileNames": true,
+		"strict": true,
+		"noImplicitOverride": true,
+		"noPropertyAccessFromIndexSignature": true,
+		"noImplicitReturns": true,
+		"noFallthroughCasesInSwitch": true
+	},
+	"files": [],
+	"include": [],
+	"references": [
+		{
+			"path": "./tsconfig.lib.json"
+		},
+		{
+			"path": "./tsconfig.spec.json"
+		}
+	]
+}

package/tsconfig.lib.json

@@ -0,0 +1,10 @@
+{
+	"extends": "./tsconfig.json",
+	"compilerOptions": {
+		"outDir": "../../../dist/out-tsc",
+		"declaration": true,
+		"types": ["node"]
+	},
+	"include": ["src/**/*.ts"],
+	"exclude": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts"]
+}

package/tsconfig.spec.json

@@ -0,0 +1,14 @@
+{
+	"extends": "./tsconfig.json",
+	"compilerOptions": {
+		"outDir": "../../../dist/out-tsc",
+		"module": "commonjs",
+		"types": ["jest", "node"]
+	},
+	"include": [
+		"jest.config.ts",
+		"src/**/*.test.ts",
+		"src/**/*.spec.ts",
+		"src/**/*.d.ts"
+	]
+}

package/vite.config.ts

@@ -0,0 +1,50 @@
+/// <reference types="vitest" />
+import { defineConfig } from 'vite';
+import viteTsConfigPaths from 'vite-tsconfig-paths';
+
+export default defineConfig(() => {
+	return {
+		assetsInclude: ['**/*.ini'],
+		cacheDir: '../../../node_modules/.vite/php-cli',
+
+		plugins: [
+			viteTsConfigPaths({
+				root: '../../../',
+			}),
+		],
+
+		// Configuration for building your library.
+		// See: https://vitejs.dev/guide/build.html#library-mode
+		build: {
+			assetsInlineLimit: 0,
+			target: 'es2020',
+			rollupOptions: {
+				external: [
+					'@php-wasm/node',
+					'net',
+					'fs',
+					'path',
+					'http',
+					'tls',
+					'util',
+					'dns',
+					'ws',
+				],
+				input: 'packages/php-wasm/cli/src/main.ts',
+				output: {
+					format: 'esm',
+					entryFileNames: '[name].js',
+				},
+			},
+		},
+
+		test: {
+			globals: true,
+			cache: {
+				dir: '../../../node_modules/.vitest',
+			},
+			environment: 'jsdom',
+			include: ['src/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+		},
+	};
+});

package/assets/php-e1f9edd4.js

@@ -1 +0,0 @@
-const p="/assets/php-9094d88a.ini";export{p as default};

package/main.js

@@ -1,5 +0,0 @@
-import{existsSync as b,writeFileSync as O}from"fs";import{rootCertificates as g}from"tls";import*as E from"dns";import*as L from"util";import*as h from"net";import{createServer as W}from"net";import*as k from"http";import{WebSocketServer as _,WebSocket as S}from"ws";import{getPHPLoaderModule as A,loadPHPRuntime as N,PHP as R}from"@php-wasm/node";const U="modulepreload",x=function(e){return"/"+e},w={},D=function(s,o,t){if(!o||o.length===0)return s();const r=document.getElementsByTagName("link");return Promise.all(o.map(l=>{if(l=x(l),l in w)return;w[l]=!0;const u=l.endsWith(".css"),i=u?'[rel="stylesheet"]':"";if(!!t)for(let c=r.length-1;c>=0;c--){const n=r[c];if(n.href===l&&(!u||n.rel==="stylesheet"))return}else if(document.querySelector(`link[href="${l}"]${i}`))return;const f=document.createElement("link");if(f.rel=u?"stylesheet":U,u||(f.as="script",f.crossOrigin=""),f.href=l,document.head.appendChild(f),u)return new Promise((c,n)=>{f.addEventListener("load",c),f.addEventListener("error",()=>n(new Error(`Unable to preload CSS for ${l}`)))})})).then(()=>s())};function C(...e){process.env.DEV&&console.log(...e)}async function I(e){const s=[];for(let r=0;r<e;r++)s.push($());const o=await Promise.all(s),t=[];for(const r of o){const l=r.address();t.push(l.port),r.close()}return t}function $(){return new Promise(e=>{const s=h.createServer();s.listen(0,()=>{e(s)})})}function v(...e){C("[WS Server]",...e)}const H=L.promisify(E.lookup);function M(e,s){if(typeof e=="string")e=String.fromCharCode(s)+e;else if(e instanceof ArrayBuffer){const o=new Uint8Array(e.byteLength+1);o[0]=s,o.set(new Uint8Array(e),1),e=o.buffer}else throw new Error("Unsupported chunk type");return e}const y=1,T=2;function B(e){return class extends e{constructor(){super(...arguments),this.CONNECTING=0,this.OPEN=1,this.CLOSING=2,this.CLOSED=3}send(o,t){return this.sendCommand(y,o,t)}setSocketOpt(o,t,r){return this.sendCommand(T,new Uint8Array([o,t,r]).buffer,()=>{})}sendCommand(o,t,r){return e.prototype.send.call(this,M(t,o),r)}}}function V(e,s="127.0.0.1"){v(`Binding the WebSockets server to ${s}:${e}...`);const o=k.createServer((t,r)=>{r.writeHead(403,{"Content-Type":"text/plain"}),r.write(`403 Permission Denied
-Only websockets are allowed here.
-`),r.end()});return new Promise(t=>{o.listen(e,s,function(){new _({server:o}).on("connection",q),t(o)})})}async function q(e,s){const o=e._socket.remoteAddress,t=function(...n){v(" "+o+": ",...n)};t("WebSocket connection from : "+o+" at URL "+(s?s.url:e.upgradeReq.url)),t("Version "+e.protocolVersion+", subprotocol: "+e.protocol);const r=new URL("ws://0.0.0.0"+s.url),l=Number(r.searchParams.get("port")),u=r.searchParams.get("host");if(!l||!u){t("Missing host or port information"),e.close(3e3);return}let i;const a=[];function f(){for(;a.length>0;){const n=a.pop(),d=n[0];t("flushing",{commandType:d},n),d===y?i.write(n.slice(1)):d===T?n[1]===1&&n[2]===9?i.setKeepAlive(n[3]):n[1]===6&&n[2]===1&&i.setNoDelay(n[3]):(t("Unknown command type: "+d),process.exit())}}e.on("message",function(n){a.unshift(n),i&&f()}),e.on("close",function(n,d){t("WebSocket client disconnected: "+n+" ["+d+"]"),i.end()}),e.on("error",function(n){t("WebSocket client error: "+n),i.end()});let c;h.isIP(u)===0?(t("resolving "+u+"... "),c=(await H(u)).address,t("resolved "+u+" -> "+c)):c=u,t("Opening a socket connection to "+c+":"+l),i=h.createConnection(l,c,function(){t("Connected to target"),f()}),i.on("data",function(n){try{e.send(n)}catch{t("Client closed, cleaning up target"),i.end()}}),i.on("end",function(){t("target disconnected"),e.close()}),i.on("error",function(n){t("target connection error",n),i.end(),e.close(3e3)})}function m(...e){C("[TCP Server]",...e)}function K(e,s){return class extends s{constructor(t,r){const l=t.port;t.port=e,F({tcpListenPort:l,wsConnectPort:e}),super(t,r)}}}function F(e){e={wsConnectHost:"127.0.0.1",...e};const{tcpListenPort:s,wsConnectHost:o,wsConnectPort:t}=e,r=W();r.on("connection",function(u){const i=[],a=new S(`ws://${o}:${t}/`);a.binaryType="arraybuffer";function f(c){a.send(new Uint8Array(c))}a.addEventListener("open",function(){for(m("Outbound WebSocket connection established");i.length>0;)f(i.shift())}),a.addEventListener("message",c=>{m("WS->TCP message:",new TextDecoder().decode(c.data)),u.write(Buffer.from(c.data))}),a.addEventListener("close",()=>{m("WebSocket connection closed"),u.end()}),u.on("data",function(c){if(m("TCP->WS message:",c),a.readyState===S.OPEN){for(;i.length>0;)f(i.shift());f(c)}else i.push(c)}),u.once("close",function(){m("TCP connection closed"),a.close()}),u.on("error",function(){m("TCP connection error"),a.close()})}),r.listen(s,function(){m("TCP server listening")})}let p=process.argv.slice(2);p.length||(p=["--help"]);const P=new URL("ca-bundle.crt",(import.meta||{}).url).pathname;b(P)||O(P,g.join(`
-`));async function j(){const e=await D(()=>import("./assets/php-e1f9edd4.js"),[]),s=process.env.PHP||"8.2",[o,t]=await I(2);await V(t);const r=await A(s),l=await N(r,{ENV:{...process.env,TERM:"xterm"},websocket:{url:(a,f,c)=>{const n=new URLSearchParams({host:f,port:c}).toString();return`ws://127.0.0.1:${t}/?${n}`},subprotocol:"binary",decorator:B,serverDecorator:K.bind(null,o)}});p.some(a=>a.startsWith("-c"))||p.unshift("-c",e);const i=new R(l);i.writeFile(P,g.join(`
-`)),p.unshift("-d",`openssl.cafile=${P}`),i.cli(["php",...p]).catch(a=>{throw a.name==="ExitStatus"&&process.exit(a.status===void 0?1:a.status),a})}j();