yaport 0.1.1 → 0.1.2

package/dist/server/cli.js

@@ -168,21 +168,109 @@ function sameEndpoint(first, second) {
 	return first.host === second.host && first.port === second.port && first.user === second.user;
 }
 //#endregion
+//#region src/server/caddyExternalRoutes.ts
+function parseCaddyExternalRoutes(caddyfile) {
+	return extractSiteAddresses(stripComments$1(caddyfile)).flatMap((address) => ({
+		port: address.port,
+		serverName: address.serverName,
+		source: "caddy",
+		url: caddyRouteUrl(address)
+	}));
+}
+function extractSiteAddresses(caddyfile) {
+	const addresses = [];
+	for (const header of extractTopLevelBlockHeaders(caddyfile)) for (const rawAddress of header.split(",")) {
+		const address = parseCaddyAddress(rawAddress.trim());
+		if (address) addresses.push(address);
+	}
+	return addresses;
+}
+function extractTopLevelBlockHeaders(caddyfile) {
+	const headers = [];
+	let depth = 0;
+	let lineStart = 0;
+	for (let index = 0; index < caddyfile.length; index += 1) {
+		const character = caddyfile[index];
+		if (character === "{") {
+			if (depth === 0) {
+				const header = caddyfile.slice(lineStart, index).trim();
+				if (header) headers.push(header);
+			}
+			depth += 1;
+			continue;
+		}
+		if (character === "}") {
+			depth = Math.max(0, depth - 1);
+			continue;
+		}
+		if (character === "\n" && depth === 0) lineStart = index + 1;
+	}
+	return headers;
+}
+function parseCaddyAddress(rawAddress) {
+	const candidate = rawAddress.trim();
+	if (candidate.startsWith("http://") || candidate.startsWith("https://")) return parseUrlAddress(candidate);
+	const address = candidate.replace(/\/.*$/, "").trim();
+	if (!address || address === "_" || address.includes("$") || address.startsWith("*.") || address.startsWith(":")) return;
+	const portMatch = address.match(/^(.+):(\d+)$/);
+	const serverName = portMatch ? portMatch[1] : address;
+	const port = portMatch ? Number(portMatch[2]) : 443;
+	if (!isDisplayableServerName$1(serverName) || !isValidPort(port)) return;
+	return {
+		port,
+		scheme: port === 443 ? "https" : "http",
+		serverName
+	};
+}
+function parseUrlAddress(address) {
+	try {
+		const url = new URL(address);
+		const scheme = url.protocol === "https:" ? "https" : "http";
+		const serverName = url.hostname;
+		const port = url.port ? Number(url.port) : scheme === "https" ? 443 : 80;
+		if (!isDisplayableServerName$1(serverName) || !isValidPort(port)) return;
+		return {
+			port,
+			scheme,
+			serverName
+		};
+	} catch {
+		return;
+	}
+}
+function stripComments$1(config) {
+	return config.split("\n").map((line) => line.replace(/(^|[^\\])#.*/, "$1")).join("\n");
+}
+function isDisplayableServerName$1(serverName) {
+	return Boolean(serverName) && !serverName.includes("*") && /^[A-Za-z0-9.-]+$/.test(serverName);
+}
+function isValidPort(port) {
+	return Number.isInteger(port) && port >= 1 && port <= 65535;
+}
+function caddyRouteUrl(address) {
+	if (address.scheme === "https" && address.port === 443) return `https://${address.serverName}`;
+	return `${address.scheme}://${address.serverName}:${address.port}`;
+}
+//#endregion
 //#region src/server/nginxExternalRoutes.ts
-function parseNginxExternalRoutes(config) {
+function parseNginxExternalRoutes(config, source = "nginx") {
 	return extractServerBlocks(stripComments(config)).flatMap((block) => {
 		const validNames = block.serverNames.filter(isDisplayableServerName);
 		return block.listens.flatMap((listen) => validNames.map((serverName) => ({
 			port: listen.port,
 			serverName,
-			source: "nginx",
+			source,
 			url: routeUrl(serverName, listen)
 		})));
 	});
 }
 function attachExternalRoutes(ports, routes) {
 	const routesByPort = /* @__PURE__ */ new Map();
-	for (const route of routes) routesByPort.set(route.port, [...routesByPort.get(route.port) ?? [], route]);
+	for (const route of routes) {
+		const currentRoutes = routesByPort.get(route.port) ?? [];
+		if (currentRoutes.some((currentRoute) => sameExternalRoute(currentRoute, route))) continue;
+		routesByPort.set(route.port, [...currentRoutes, route]);
+	}
 	return ports.map((port) => {
 		const externalRoutes = routesByPort.get(port.port);
 		if (!externalRoutes?.length) return port;
@@ -192,6 +280,9 @@ function attachExternalRoutes(ports, routes) {
 		};
 	});
 }
+function sameExternalRoute(left, right) {
+	return left.port === right.port && left.serverName === right.serverName && left.source === right.source && left.url === right.url;
+}
 function stripComments(config) {
 	return config.split("\n").map((line) => line.replace(/(^|[^\\])#.*/, "$1")).join("\n");
 }
@@ -309,6 +400,33 @@ function parseProcess(value) {
 	};
 }
 //#endregion
+//#region src/server/sshConnection.ts
+var SSH_CONTROL_SOCKET_DIRECTORY = "/tmp/yaport-ssh";
+async function ensureSshControlSocketDirectory() {
+	await mkdir(SSH_CONTROL_SOCKET_DIRECTORY, {
+		recursive: true,
+		mode: 448
+	});
+}
+function buildSshControlPath(machine) {
+	return join(SSH_CONTROL_SOCKET_DIRECTORY, machineConnectionHash(machine).slice(0, 40));
+}
+function machineConnectionHash(machine) {
+	return createHash("sha256").update(JSON.stringify(machineConnectionIdentity(machine))).digest("hex");
+}
+function machineConnectionIdentity(machine) {
+	return {
+		host: machine.host,
+		port: machine.port,
+		user: machine.user,
+		jumpHosts: machine.jumpHosts?.map((jumpHost) => ({
+			host: jumpHost.host,
+			port: jumpHost.port,
+			user: jumpHost.user
+		}))
+	};
+}
+//#endregion
 //#region src/server/sshPortInventory.ts
 var SshCommandError = class extends Error {
 	stderr;
@@ -318,9 +436,8 @@ var SshCommandError = class extends Error {
 		this.name = "SshCommandError";
 	}
 };
-var CONTROL_SOCKET_DIRECTORY = "/tmp/yaport-ssh";
-var NGINX_EXTERNAL_ROUTE_CACHE_MS = 300 * 1e3;
-var nginxExternalRouteCache = /* @__PURE__ */ new Map();
+var PROXY_EXTERNAL_ROUTE_CACHE_MS = 300 * 1e3;
+var proxyExternalRouteCache = /* @__PURE__ */ new Map();
 async function collectPortInventory(machine, runner = runSsh, options = {}) {
 	const sshOptions = buildSshOptions(machine);
 	const sshArgsOptions = await buildSshArgsOptions(machine, options);
@@ -330,7 +447,7 @@ async function collectPortInventory(machine, runner = runSsh, options = {}) {
 		"-lntup"
 	], sshArgsOptions), sshOptions);
 	const ports = parseSsListeningPorts(stdout);
-	const [portsWithCommandsResult, externalRoutesResult] = await Promise.allSettled([attachProcessCommands(machine, ports, runner, sshOptions, sshArgsOptions), readCachedNginxExternalRoutes(machine, runner, sshOptions, sshArgsOptions)]);
+	const [portsWithCommandsResult, externalRoutesResult] = await Promise.allSettled([attachProcessCommands(machine, ports, runner, sshOptions, sshArgsOptions), readCachedProxyExternalRoutes(machine, ports, runner, sshOptions, sshArgsOptions)]);
 	return attachExternalRoutes(portsWithCommandsResult.status === "fulfilled" ? portsWithCommandsResult.value : ports, externalRoutesResult.status === "fulfilled" ? externalRoutesResult.value : []);
 }
 async function attachProcessCommands(machine, ports, runner, sshOptions, sshArgsOptions) {
@@ -357,24 +474,33 @@ async function attachProcessCommands(machine, ports, runner, sshOptions, sshArgs
 		return ports;
 	}
 }
-async function readCachedNginxExternalRoutes(machine, runner, sshOptions, sshArgsOptions) {
+async function readCachedProxyExternalRoutes(machine, ports, runner, sshOptions, sshArgsOptions) {
+	const proxySources = proxySourcesForPorts(ports);
+	if (proxySources.length === 0) return [];
 	const cacheKey = machineConnectionCacheKey(machine);
-	const cached = nginxExternalRouteCache.get(cacheKey);
+	const cached = proxyExternalRouteCache.get(cacheKey);
 	if (cached && cached.expiresAt > Date.now()) return cached.routes;
-	try {
-		const routes = parseNginxExternalRoutes((await runner(buildSshArgs(machine, ["nginx", "-T"], sshArgsOptions), sshOptions)).stdout);
-		nginxExternalRouteCache.set(cacheKey, {
-			expiresAt: Date.now() + NGINX_EXTERNAL_ROUTE_CACHE_MS,
-			routes
-		});
-		return routes;
-	} catch {
-		nginxExternalRouteCache.set(cacheKey, {
-			expiresAt: Date.now() + NGINX_EXTERNAL_ROUTE_CACHE_MS,
-			routes: []
-		});
-		return [];
+	const routes = (await Promise.allSettled(proxySources.map((source) => readProxyExternalRoutes(machine, source, runner, sshOptions, sshArgsOptions)))).flatMap((result) => result.status === "fulfilled" ? result.value : []);
+	proxyExternalRouteCache.set(cacheKey, {
+		expiresAt: Date.now() + PROXY_EXTERNAL_ROUTE_CACHE_MS,
+		routes
+	});
+	return routes;
+}
+function proxySourcesForPorts(ports) {
+	const sources = /* @__PURE__ */ new Set();
+	for (const port of ports) {
+		const processName = port.processName?.toLowerCase() ?? "";
+		if (processName.includes("nginx")) sources.add("nginx");
+		if (processName.includes("openresty")) sources.add("openresty");
+		if (processName.includes("tengine")) sources.add("tengine");
+		if (processName.includes("caddy")) sources.add("caddy");
 	}
+	return [...sources];
+}
+async function readProxyExternalRoutes(machine, source, runner, sshOptions, sshArgsOptions) {
+	if (source === "caddy") return parseCaddyExternalRoutes((await runner(buildSshArgs(machine, ["cat", "/etc/caddy/Caddyfile"], sshArgsOptions), sshOptions)).stdout);
+	return parseNginxExternalRoutes((await runner(buildSshArgs(machine, [source, "-T"], sshArgsOptions), sshOptions)).stdout, source);
 }
 function buildSshOptions(machine) {
 	const entries = buildAskPassEntries(machine);
@@ -395,11 +521,8 @@ function parsePsCommands(output) {
 }
 async function buildSshArgsOptions(machine, options) {
 	if (!options.reuseConnection) return {};
-	await mkdir(CONTROL_SOCKET_DIRECTORY, {
-		recursive: true,
-		mode: 448
-	});
-	return { controlPath: join(CONTROL_SOCKET_DIRECTORY, machineConnectionHash(machine).slice(0, 40)) };
+	await ensureSshControlSocketDirectory();
+	return { controlPath: buildSshControlPath(machine) };
 }
 function buildSshArgs(machine, command, options = {}) {
 	const hasPasswords = buildAskPassEntries(machine).length > 0;
@@ -418,21 +541,6 @@ function buildSshArgs(machine, command, options = {}) {
 function machineConnectionCacheKey(machine) {
 	return `${machine.id}:${machineConnectionHash(machine)}`;
 }
-function machineConnectionHash(machine) {
-	return createHash("sha256").update(JSON.stringify(machineConnectionIdentity(machine))).digest("hex");
-}
-function machineConnectionIdentity(machine) {
-	return {
-		host: machine.host,
-		port: machine.port,
-		user: machine.user,
-		jumpHosts: machine.jumpHosts?.map((jumpHost) => ({
-			host: jumpHost.host,
-			port: jumpHost.port,
-			user: jumpHost.user
-		}))
-	};
-}
 function buildAskPassEntries(machine) {
 	return [...machine.jumpHosts ?? [], machine].flatMap((endpoint) => endpoint.password ? [{
 		password: endpoint.password,
@@ -556,8 +664,9 @@ var UnsupportedTerminalError = class extends Error {
 		this.name = "UnsupportedTerminalError";
 	}
 };
-function buildInteractiveSshArgs(machine) {
+function buildInteractiveSshArgs(machine, options = {}) {
 	const args = [];
+	if (options.controlPath) args.push("-o", "ControlMaster=auto", "-o", "ControlPersist=5m", "-o", `ControlPath=${options.controlPath}`);
 	if (machine.jumpHosts?.length) args.push("-J", machine.jumpHosts.map(formatJumpHost).join(","));
 	if (machine.port) args.push("-p", String(machine.port));
 	args.push(formatSshTarget(machine));
@@ -566,11 +675,13 @@ function buildInteractiveSshArgs(machine) {
 async function openSshTerminal(machine, options = {}) {
 	const platform = options.platform ?? process.platform;
 	if (platform !== "darwin") throw new UnsupportedTerminalError(platform);
-	await runCommand(options.spawnCommand ?? spawn, "osascript", [
+	const spawnCommand = options.spawnCommand ?? spawn;
+	await ensureSshControlSocketDirectory();
+	await runCommand(spawnCommand, "osascript", [
 		"-e",
 		"tell application \"Terminal\" to activate",
 		"-e",
-		`tell application "Terminal" to do script ${appleScriptString(["ssh", ...buildInteractiveSshArgs(machine)].map(shellQuote).join(" "))}`
+		`tell application "Terminal" to do script ${appleScriptString(["ssh", ...buildInteractiveSshArgs(machine, { controlPath: buildSshControlPath(machine) })].map(shellQuote).join(" "))}`
 	]);
 }
 function runCommand(spawnCommand, command, args) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yaport",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "type": "module",
   "packageManager": "pnpm@11.5.0",
   "bin": {