@vlandoss/localproxy 0.0.10 → 0.0.11-git-06df4ba.0

package/bin.ts

@@ -1,9 +1,10 @@
 #!/usr/bin/env bun
 import { homedir } from "node:os";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { main } from "./src/main";
 
 main({
-  binDir: __dirname,
+  binDir: path.dirname(fileURLToPath(import.meta.url)),
   installDir: path.join(homedir(), ".localproxy"),
 });

package/dist/bin.mjs

@@ -0,0 +1,416 @@
+#!/usr/bin/env node
+import { homedir } from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createPkgService, createShellService, getVersion, palette } from "@vlandoss/clibuddy";
+import { createCommand } from "commander";
+import * as fs$2 from "node:fs";
+import { createLoggy } from "@vlandoss/loggy";
+import * as fs$1 from "node:fs/promises";
+import fs from "node:fs/promises";
+import { editor, password } from "@inquirer/prompts";
+//#region src/services/logger.ts
+const logger = createLoggy({ namespace: "localproxy" });
+//#endregion
+//#region src/services/shell.ts
+const quietShell = createShellService({
+	quiet: true,
+	verbose: false
+});
+const silentShell = quietShell.child({ stdio: "ignore" });
+const verboseShell = quietShell.child({
+	quiet: false,
+	verbose: true,
+	stdio: "inherit"
+});
+//#endregion
+//#region src/services/caddy.ts
+const debug$4 = logger.subdebug("caddy");
+var CaddyService = class {
+	#configPath;
+	#pidFilePath;
+	constructor(configPath) {
+		this.#configPath = configPath;
+		this.#pidFilePath = path.join(path.dirname(configPath), "caddy.pid");
+		this.#initCaddyPid();
+	}
+	#initCaddyPid() {
+		if (!this.#hasCaddyPid()) fs$2.writeFileSync(this.#pidFilePath, "");
+	}
+	#hasCaddyPid() {
+		return fs$2.existsSync(this.#pidFilePath);
+	}
+	#deleteCaddyPid() {
+		if (this.#hasCaddyPid()) fs$2.rmSync(this.#pidFilePath);
+	}
+	#shell({ verbose }) {
+		return verbose ? verboseShell : silentShell;
+	}
+	#getPID() {
+		return this.#hasCaddyPid() ? fs$2.readFileSync(this.#pidFilePath, "utf-8").trim() : null;
+	}
+	async reboot(options) {
+		if (await this.isRunning()) await this.stop(options);
+		await this.start(options);
+	}
+	async start({ verbose }) {
+		if (await this.isRunning()) {
+			logger.warn("Caddy is already running. PID: %d", this.#getPID());
+			return;
+		}
+		const { $ } = this.#shell({ verbose });
+		try {
+			logger.start("Starting Caddy");
+			await $`caddy start -c ${this.#configPath} --pidfile ${this.#pidFilePath} > /dev/null 2>&1`;
+			logger.success("Caddy started");
+		} catch {
+			logger.error("Can't start Caddy");
+			process.exit(1);
+		}
+	}
+	async stop({ verbose }) {
+		const { $ } = this.#shell({ verbose });
+		try {
+			logger.start("Stopping Caddy");
+			await $`caddy stop -c ${this.#configPath}`;
+			this.#deleteCaddyPid();
+			logger.success("Caddy stopped");
+		} catch {
+			logger.error("Can't stop Caddy");
+			process.exit(1);
+		}
+	}
+	async isRunning() {
+		if (!this.#hasCaddyPid()) return false;
+		const pid = this.#getPID();
+		debug$4("caddy PID: %d", pid);
+		const { exitCode } = await quietShell.$`kill -0 ${pid}`.nothrow();
+		const isRunning = exitCode === 0;
+		debug$4("caddy is %s", isRunning ? "running" : "stopped");
+		return isRunning;
+	}
+};
+//#endregion
+//#region src/services/caddyfile/parser.ts
+var CaddyfileParser = class {
+	#content;
+	constructor(content) {
+		this.#content = content;
+	}
+	parse() {
+		return { siteBlocks: this.#extractSiteBlocks(this.#content) };
+	}
+	#extractSiteBlocks(content) {
+		const siteBlocks = [];
+		const bracedBlockRegex = /([^{]+)\s*\{([^}]*)\}/gs;
+		let match;
+		const processedContent = /* @__PURE__ */ new Set();
+		while ((match = bracedBlockRegex.exec(content)) !== null) {
+			const [fullMatch, sitesStr, directivesStr] = match;
+			processedContent.add(fullMatch.trim());
+			const sites = sitesStr ? this.#parseSites(sitesStr.trim()) : [];
+			const directives = directivesStr ? this.#parseDirectives(directivesStr.trim()) : [];
+			if (sites.length > 0) siteBlocks.push({
+				sites,
+				directives
+			});
+		}
+		return siteBlocks;
+	}
+	#parseSites(sitesStr) {
+		if (!sitesStr.trim()) return [];
+		return sitesStr.split(/[,\s]+/).map((site) => site.trim()).filter((site) => site.length > 0);
+	}
+	#parseDirectives(directivesStr) {
+		const directives = [];
+		if (!directivesStr.trim()) return directives;
+		const lines = directivesStr.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+		for (const line of lines) {
+			const directive = this.#parseDirectiveLine(line);
+			if (directive) directives.push(directive);
+		}
+		return directives;
+	}
+	#parseDirectiveLine(line) {
+		const match = line.match(/^(\w+)(?:\s+(.+))?$/);
+		if (!match) return null;
+		const [, directiveType, argsStr] = match;
+		const directive = {
+			type: directiveType,
+			arguments: []
+		};
+		if (argsStr) {
+			const args = argsStr.split(/\s+/).filter((arg) => arg.length > 0);
+			if (args.length > 0 && this.#looksLikeMatcher(args[0])) {
+				directive.matchToken = args[0];
+				directive.arguments = args.slice(1);
+			} else directive.arguments = args;
+		}
+		return directive;
+	}
+	#looksLikeMatcher(token) {
+		return token === "*" || token.startsWith("/") || token.startsWith("@");
+	}
+};
+//#endregion
+//#region src/services/caddyfile/service.ts
+const debug$3 = logger.subdebug("caddyfile-service");
+const LOCALHOST_REGEX = /localhost(:\d+)?/;
+var CaddyfileService = class {
+	#filepath;
+	constructor(filepath) {
+		this.#filepath = filepath;
+	}
+	async getLocalDomains() {
+		const domains = new CaddyfileParser(await fs$1.readFile(this.#filepath, "utf-8")).parse().siteBlocks.flatMap((block) => {
+			const ports = block.directives.filter((d) => d.type === "reverse_proxy" && d.arguments.some((arg) => this.#isLocalhost(arg))).flatMap((d) => d.arguments).filter((arg) => this.#isLocalhost(arg)).map((arg) => arg.split(":")[1]);
+			return block.sites.map((site) => {
+				return {
+					hostname: site,
+					ports
+				};
+			});
+		});
+		debug$3("detected domains: %o", domains);
+		return domains;
+	}
+	#isLocalhost(arg) {
+		return LOCALHOST_REGEX.test(arg);
+	}
+};
+//#endregion
+//#region src/services/sudo.ts
+const debug$2 = logger.subdebug("sudo");
+var SudoService = class {
+	#shell;
+	constructor() {
+		this.#shell = silentShell.child({ stdio: [
+			"ignore",
+			"ignore",
+			"pipe"
+		] });
+	}
+	async auth() {
+		if (!await this.isAuthorized()) await this.authenticate();
+	}
+	async isAuthorized() {
+		const { exitCode } = await this.#shell.$`sudo -v -n`.nothrow();
+		return exitCode === 0;
+	}
+	async authenticate() {
+		let intent = 1;
+		let exitCode = null;
+		await password({
+			message: "Enter sudo password to manage hosts",
+			mask: true,
+			validate: async (value) => {
+				debug$2("Attempting sudo authentication %o", { intent });
+				const output = await this.#shell.$`echo "${value}" | sudo -S -v`.nothrow();
+				exitCode = output.exitCode;
+				debug$2("Sudo authentication exitCode(%d)", exitCode);
+				if (intent >= 3) return true;
+				intent++;
+				return output.exitCode === 0 ? true : "Invalid password";
+			}
+		});
+		if (exitCode !== 0) {
+			logger.error("`sudo` authentication failed");
+			process.exit(1);
+		}
+	}
+};
+//#endregion
+//#region src/services/hosts.ts
+const debug$1 = logger.subdebug("hosts");
+var HostsService = class {
+	#sudo;
+	constructor() {
+		this.#sudo = new SudoService();
+	}
+	#shell({ verbose }) {
+		return verbose ? verboseShell : silentShell;
+	}
+	async setup(options) {
+		const { hostnames } = options;
+		logger.start("Setting up hosts");
+		await this.#sudo.auth();
+		const { $ } = this.#shell(options);
+		await $`sudo hosts backups create`;
+		for (const host of hostnames) await this.addHost(host, options);
+		logger.success("Hosts ready");
+	}
+	async clean(options) {
+		const { hostnames } = options;
+		await this.#sudo.auth();
+		for (const host of hostnames) await this.removeHost(host, options);
+	}
+	async findHost(host) {
+		const { exitCode } = await quietShell.$`hosts show "${host}"`.nothrow();
+		const found = exitCode === 0;
+		debug$1("Host %s is %s", host, found ? "present" : "absent");
+		return found;
+	}
+	async addHost(host, options) {
+		const { $ } = this.#shell(options);
+		if (!await this.findHost(host)) await $`sudo hosts add 127.0.0.1 ${host}`;
+	}
+	async removeHost(host, options) {
+		const { $ } = this.#shell(options);
+		if (!await this.findHost(host)) await $`sudo hosts remove ${host}`;
+	}
+	async getEnabledHosts() {
+		return (await quietShell.$`hosts list enabled`.text()).split("\n").map((line) => {
+			const [ip, hostname] = line.split(/\s+/);
+			if (!ip || !hostname) return null;
+			return {
+				ip,
+				hostname
+			};
+		}).filter(Boolean);
+	}
+};
+//#endregion
+//#region src/commands/clean.ts
+function createCleanCommand({ caddyfilePath }) {
+	return createCommand("clean").description("clean up config files").option("--verbose", "verbose mode, show background output", false).action(async function cleanAction(options) {
+		const { verbose } = options;
+		await new CaddyService(caddyfilePath).stop({ verbose });
+		const hostnames = (await new CaddyfileService(caddyfilePath).getLocalDomains()).map((d) => d.hostname);
+		await new HostsService().clean({
+			verbose,
+			hostnames
+		});
+		logger.success("Clean completed!");
+	});
+}
+//#endregion
+//#region src/services/file.ts
+var FileService = class {
+	#filePath;
+	constructor(filePath) {
+		this.#filePath = filePath;
+	}
+	async print() {
+		const fileContent = (await fs.readFile(this.#filePath)).toString();
+		console.log(`${this.#filePath}:\n`);
+		console.log(fileContent.trim());
+	}
+};
+//#endregion
+//#region src/commands/setup.ts
+const debug = logger.subdebug("setup");
+async function checkInternalTools() {
+	const { $ } = quietShell;
+	const caddyVersion = await $`caddy --version`.nothrow();
+	if (caddyVersion.exitCode) {
+		logger.error("Caddy is not installed. Please install Caddy first:");
+		logger.info("macOS: brew install caddy");
+		logger.info("Linux: https://caddyserver.com/docs/install");
+		process.exit(1);
+	}
+	debug("caddy version: %s", caddyVersion.stdout.trim());
+	const hostsVersion = await $`hosts --version`.nothrow();
+	if (!hostsVersion) {
+		logger.error("hosts CLI tool is not installed. Please install hosts first:");
+		logger.info("macOS: brew tap xwmx/taps && brew install hosts");
+		logger.info("Linux: Check https://github.com/xwmx/hosts for installation");
+		process.exit(1);
+	}
+	debug("hosts version: %s", hostsVersion.stdout.trim());
+}
+function createSetupCommand({ binDir, installDir, caddyfilePath }) {
+	return createCommand("setup").description("setup config files").option("--verbose", "verbose mode, show background output", false).action(async function setupAction(options) {
+		const { verbose } = options;
+		await checkInternalTools();
+		if (!await fs$1.exists(installDir)) await fs$1.mkdir(installDir);
+		const exampleCaddyFilePath = path.join(binDir, "config", "Caddyfile.example");
+		const fileContent = await editor({
+			message: "Caddyfile",
+			default: await fs$1.exists(caddyfilePath) ? await fs$1.readFile(caddyfilePath, "utf-8") : await fs$1.readFile(exampleCaddyFilePath, "utf-8")
+		});
+		await fs$1.writeFile(caddyfilePath, fileContent);
+		await new FileService(caddyfilePath).print();
+		await new CaddyService(caddyfilePath).reboot({ verbose });
+		const hostnames = (await new CaddyfileService(caddyfilePath).getLocalDomains()).map((d) => d.hostname);
+		await new HostsService().setup({
+			verbose,
+			hostnames
+		});
+		logger.success("Setup completed!");
+	});
+}
+//#endregion
+//#region src/commands/start.ts
+function createStartCommand({ caddyfilePath }) {
+	return createCommand("start").description("start caddy server").option("--verbose", "verbose mode, show background output", false).action(async function startAction(options) {
+		await new CaddyService(caddyfilePath).start(options);
+		logger.success("Start completed!");
+	});
+}
+//#endregion
+//#region src/commands/status.ts
+function createStatusCommand({ caddyfilePath }) {
+	return createCommand("status").description("show configured localhosts").action(async function statusAction() {
+		if (await new CaddyService(caddyfilePath).isRunning()) logger.info("Caddy is running");
+		else logger.warn("Caddy is not running. Use `localp start` to start it.");
+		await new FileService(caddyfilePath).print();
+		const localDomains = await new CaddyfileService(caddyfilePath).getLocalDomains();
+		const enabledHosts = await new HostsService().getEnabledHosts();
+		localDomains.forEach(({ hostname, ports }) => {
+			const enabled = enabledHosts.some((h) => h.hostname === hostname);
+			const formattedPorts = ports.map((p) => `:${p}`).join(", ");
+			if (enabled) logger.success("`%s` is configured -> %s", hostname, formattedPorts);
+			else logger.warn("`%s` is not configured -> %s", hostname, formattedPorts);
+		});
+	});
+}
+//#endregion
+//#region src/commands/stop.ts
+function createStopCommand({ caddyfilePath }) {
+	return createCommand("stop").description("stop caddy server").option("--verbose", "verbose mode, show background output", false).action(async function stopAction(options) {
+		await new CaddyService(caddyfilePath).stop(options);
+		logger.success("Stop completed!");
+	});
+}
+const BANNER_TEXT = `${`🛠️ ${palette.bold("localproxy")}`}: Simple local development proxy automation\n`;
+const CREDITS_TEXT = `\nAcknowledgment:
+- Caddy: for being a powerful proxy server
+  ${palette.link("https://caddyserver.com")}
+
+- hosts: making it easier to manage host file
+  ${palette.link("https://github.com/xwmx/hosts")}`;
+//#endregion
+//#region src/main.ts
+async function createContext({ binDir, installDir }) {
+	const binPkg = await createPkgService(binDir);
+	if (!binPkg) throw new Error("Could not find bin package.json");
+	return {
+		installDir,
+		caddyfilePath: path.join(installDir, "Caddyfile"),
+		binDir,
+		binPkg
+	};
+}
+async function createProgram(options) {
+	const ctx = await createContext(options);
+	return createCommand("localproxy").alias("localp").version(getVersion(ctx.binPkg), "-v, --version").addHelpText("before", BANNER_TEXT).addHelpText("after", CREDITS_TEXT).addCommand(createSetupCommand(ctx)).addCommand(createStatusCommand(ctx)).addCommand(createStartCommand(ctx)).addCommand(createStopCommand(ctx)).addCommand(createCleanCommand(ctx));
+}
+async function main(options) {
+	try {
+		await (await createProgram(options)).parseAsync();
+	} catch (error) {
+		if (error instanceof Error && error.name === "ExitPromptError") logger.success("👋 cancelled, until next time!");
+		else {
+			logger.error(error);
+			process.exit(1);
+		}
+	}
+}
+//#endregion
+//#region bin.ts
+main({
+	binDir: path.dirname(fileURLToPath(import.meta.url)),
+	installDir: path.join(homedir(), ".localproxy")
+});
+//#endregion
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vlandoss/localproxy",
-  "version": "0.0.10",
+  "version": "0.0.11-git-06df4ba.0",
   "description": "Simple local development proxy automation",
   "homepage": "https://github.com/variableland/dx/tree/main/packages/localproxy#readme",
   "bugs": {
@@ -8,34 +8,43 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/variableland/dx.git"
+    "url": "git+https://github.com/variableland/dx.git",
+    "directory": "packages/localproxy"
   },
   "license": "MIT",
   "author": "rcrd <rcrd@variable.land>",
   "type": "module",
   "bin": {
-    "localproxy": "./bin.ts",
-    "localp": "./bin.ts"
+    "localproxy": "./dist/bin.mjs",
+    "localp": "./dist/bin.mjs"
   },
   "files": [
-    "bin",
+    "bin.ts",
+    "dist",
     "src",
+    "!src/**/__tests__",
+    "!src/**/*.test.*",
     "config",
     "tsconfig.json"
   ],
   "dependencies": {
     "@inquirer/prompts": "8.3.0",
     "commander": "14.0.3",
-    "@vlandoss/clibuddy": "0.0.10",
-    "@vlandoss/loggy": "0.0.7"
+    "@vlandoss/loggy": "0.0.8-git-06df4ba.0",
+    "@vlandoss/clibuddy": "0.0.11-git-06df4ba.0"
   },
   "publishConfig": {
     "access": "public"
   },
   "engines": {
+    "node": ">=20.0.0",
     "bun": ">=1.0.0"
   },
+  "devDependencies": {
+    "@vlandoss/tsdown-config": "^0.0.2-git-06df4ba.0"
+  },
   "scripts": {
+    "build": "tsdown",
     "test": "bun test",
     "test:types": "rr tsc"
   }