@vlandoss/localproxy 0.0.1 → 0.0.2-git-cd6be95.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vlandoss/localproxy",
-  "version": "0.0.1",
+  "version": "0.0.2-git-cd6be95.0",
   "description": "Simple local development proxy automation",
   "homepage": "https://github.com/variableland/dx/tree/main/packages/localproxy#readme",
   "bugs": {
@@ -27,7 +27,7 @@
     "@inquirer/prompts": "^7.8.4",
     "commander": "13.1.0",
     "@vlandoss/clibuddy": "0.0.5",
-    "@vlandoss/loggy": "0.0.4"
+    "@vlandoss/loggy": "0.0.5-git-cd6be95.0"
   },
   "publishConfig": {
     "access": "public"

package/src/commands/clean.ts

@@ -12,7 +12,7 @@ export function createCleanCommand({ caddyfilePath }: Context) {
   return createCommand("clean")
     .description("clean up config files")
     .option("--verbose", "verbose mode, show background output", false)
-    .action(async (options: CommandOptions) => {
+    .action(async function cleanAction(options: CommandOptions) {
       const caddyService = new CaddyService(caddyfilePath);
       await caddyService.stop(options);
 
@@ -22,6 +22,6 @@ export function createCleanCommand({ caddyfilePath }: Context) {
       const hostsService = new HostsService(hosts);
       await hostsService.clean(options);
 
-      logger.success("localproxy clean completed");
+      logger.success("Clean completed!");
     });
 }

package/src/commands/setup.ts

@@ -1,6 +1,6 @@
 import * as fs from "node:fs/promises";
 import path from "node:path";
-import { editor } from "@inquirer/prompts";
+import { editor as editorPrompt } from "@inquirer/prompts";
 import { createCommand } from "commander";
 import { CaddyService } from "~/services/caddy";
 import { HostsService } from "~/services/hosts";
@@ -33,7 +33,7 @@ async function checkInternalTools() {
     process.exit(1);
   }
 
-  debug("Caddy version: %s", caddyVersion.stdout.trim());
+  debug("caddy version: %s", caddyVersion.stdout.trim());
 
   const hostsVersion = await $`hosts --version`.nothrow();
 
@@ -51,7 +51,7 @@ export function createSetupCommand({ binDir, installDir, caddyfilePath }: Contex
   return createCommand("setup")
     .description("setup config files")
     .option("--verbose", "verbose mode, show background output", false)
-    .action(async (options: CommandOptions) => {
+    .action(async function setupAction(options: CommandOptions) {
       debug("setup command options %o", options);
 
       await checkInternalTools();
@@ -65,7 +65,7 @@ export function createSetupCommand({ binDir, installDir, caddyfilePath }: Contex
         ? await fs.readFile(caddyfilePath, "utf-8")
         : await fs.readFile(exampleCaddyFilePath, "utf-8");
 
-      const fileContent = await editor({
+      const fileContent = await editorPrompt({
         message: "Caddyfile",
         default: defaultContent,
       });
@@ -83,6 +83,6 @@ export function createSetupCommand({ binDir, installDir, caddyfilePath }: Contex
       const hostsService = new HostsService(hosts);
       await hostsService.setup(options);
 
-      logger.success("localproxy setup completed");
+      logger.success("Setup completed!");
     });
 }

package/src/commands/start.ts

@@ -11,10 +11,10 @@ export function createStartCommand({ caddyfilePath }: Context) {
   return createCommand("start")
     .description("start caddy server")
     .option("--verbose", "verbose mode, show background output", false)
-    .action(async (options: CommandOptions) => {
+    .action(async function startAction(options: CommandOptions) {
       const caddyService = new CaddyService(caddyfilePath);
       await caddyService.start(options);
 
-      logger.success("localproxy start completed");
+      logger.success("Start completed!");
     });
 }

package/src/commands/status.ts

@@ -7,14 +7,13 @@ import type { Context } from "~/types";
 export function createStatusCommand({ caddyfilePath }: Context) {
   return createCommand("status")
     .description("show configured localhosts")
-    .option("--verbose", "verbose mode, show background output", false)
-    .action(async () => {
+    .action(async function statusAction() {
       const caddyService = new CaddyService(caddyfilePath);
 
       if (await caddyService.isRunning()) {
         logger.info("Caddy is running");
       } else {
-        logger.warn("Caddy is not running");
+        logger.warn("Caddy is not running. Use `localp start` to start it.");
       }
 
       const localDomains = caddyService.getLocalDomains();
@@ -27,9 +26,9 @@ export function createStatusCommand({ caddyfilePath }: Context) {
         const found = await hostsService.findHost(host);
 
         if (found) {
-          logger.success("%s is configured -> :%s", host, port);
+          logger.success("`%s` is configured -> :%s", host, port);
         } else {
-          logger.warn("%s is not configured -> :%s", host, port);
+          logger.warn("`%s` is not configured -> :%s", host, port);
         }
       }
     });

package/src/commands/stop.ts

@@ -11,10 +11,10 @@ export function createStopCommand({ caddyfilePath }: Context) {
   return createCommand("stop")
     .description("stop caddy server")
     .option("--verbose", "verbose mode, show background output", false)
-    .action(async (options: CommandOptions) => {
+    .action(async function stopAction(options: CommandOptions) {
       const caddyService = new CaddyService(caddyfilePath);
       await caddyService.stop(options);
 
-      logger.success("localproxy stop completed");
+      logger.success("Stop completed!");
     });
 }

package/src/services/caddy.ts

@@ -44,6 +44,10 @@ export class CaddyService {
     return verbose ? verboseShell : silentShell;
   }
 
+  #getPID() {
+    return this.#hasCaddyPid() ? fs.readFileSync(this.#pidFilePath, "utf-8").trim() : null;
+  }
+
   async reboot(options: ExecOption) {
     const isRunning = await this.isRunning();
     if (isRunning) {
@@ -53,14 +57,19 @@ export class CaddyService {
   }
 
   async start({ verbose }: ExecOption) {
+    if (await this.isRunning()) {
+      logger.warn("Caddy is already running. PID: %d", this.#getPID());
+      return;
+    }
+
     const { $ } = this.#shell({ verbose });
 
     try {
-      debug("Starting Caddy...");
+      logger.start("Starting Caddy");
 
       await $`caddy start -c ${this.#configPath} --pidfile ${this.#pidFilePath} > /dev/null 2>&1`;
 
-      debug("Caddy started");
+      logger.success("Caddy started");
     } catch {
       logger.error("Can't start Caddy");
       process.exit(1);
@@ -71,12 +80,12 @@ export class CaddyService {
     const { $ } = this.#shell({ verbose });
 
     try {
-      debug("Stopping Caddy...");
+      logger.start("Stopping Caddy");
 
       await $`caddy stop -c ${this.#configPath}`;
       this.#deleteCaddyPid();
 
-      debug("Caddy stopped");
+      logger.success("Caddy stopped");
     } catch {
       logger.error("Can't stop Caddy");
       process.exit(1);
@@ -88,14 +97,14 @@ export class CaddyService {
       return false;
     }
 
-    const pid = (await quietShell.$`cat ${this.#pidFilePath}`.text()).trim();
+    const pid = this.#getPID();
 
-    debug("Caddy PID: %d", pid);
+    debug("caddy PID: %d", pid);
 
     const { exitCode } = await quietShell.$`kill -0 ${pid}`.nothrow();
     const isRunning = exitCode === 0;
 
-    debug("Caddy is %s", isRunning ? "running" : "stopped");
+    debug("caddy is %s", isRunning ? "running" : "stopped");
 
     return isRunning;
   }

package/src/services/hosts.ts

@@ -1,5 +1,6 @@
 import { logger } from "./logger";
 import { quietShell, silentShell, verboseShell } from "./shell";
+import { SudoService } from "./sudo";
 
 type SetupOptions = {
   verbose: boolean;
@@ -9,9 +10,11 @@ const debug = logger.subdebug("hosts");
 
 export class HostsService {
   #hosts: string[];
+  #sudo: SudoService;
 
   constructor(domains: string[]) {
     this.#hosts = domains;
+    this.#sudo = new SudoService();
   }
 
   #shell({ verbose }: SetupOptions) {
@@ -19,31 +22,42 @@ export class HostsService {
   }
 
   async setup(options: SetupOptions) {
-    await verboseShell.$`sudo hosts backups create`;
+    logger.start("Setting up hosts");
+
+    await this.#sudo.auth();
+
+    const { $ } = this.#shell(options);
+
+    await $`sudo hosts backups create`;
 
     for (const host of this.#hosts) {
       await this.addHost(host, options);
     }
+
+    logger.success("Hosts ready");
   }
 
   async clean(options: SetupOptions) {
+    await this.#sudo.auth();
+
     for (const host of this.#hosts) {
       await this.removeHost(host, options);
     }
   }
 
   async findHost(host: string) {
-    const currentHost = await quietShell.$`hosts show "${host}"`.text();
-    debug("Host %s is %s", host, currentHost ? "present" : "absent");
-    return currentHost;
+    const { exitCode } = await quietShell.$`hosts show "${host}"`.nothrow();
+    const found = exitCode === 0;
+    debug("Host %s is %s", host, found ? "present" : "absent");
+    return found;
   }
 
   async addHost(host: string, options: SetupOptions) {
     const { $ } = this.#shell(options);
 
-    const currentHost = await this.findHost(host);
+    const found = await this.findHost(host);
 
-    if (!currentHost) {
+    if (!found) {
       await $`sudo hosts add 127.0.0.1 ${host}`;
     }
   }
@@ -51,9 +65,9 @@ export class HostsService {
   async removeHost(host: string, options: SetupOptions) {
     const { $ } = this.#shell(options);
 
-    const currentHost = await this.findHost(host);
+    const found = await this.findHost(host);
 
-    if (!currentHost) {
+    if (!found) {
       await $`sudo hosts remove ${host}`;
     }
   }

package/src/services/shell.ts

@@ -6,11 +6,11 @@ export const quietShell = createShellService({
 });
 
 export const silentShell = quietShell.child({
-  stdio: ["ignore", "ignore", "ignore"],
+  stdio: "ignore",
 });
 
 export const verboseShell = quietShell.child({
   quiet: false,
   verbose: true,
-  stdio: ["inherit", "inherit", "inherit"],
+  stdio: "inherit",
 });

package/src/services/sudo.ts

@@ -0,0 +1,58 @@
+import { password as passwordPrompt } from "@inquirer/prompts";
+import type { ShellService } from "@vlandoss/clibuddy";
+import { logger } from "./logger";
+import { silentShell } from "./shell";
+
+const debug = logger.subdebug("sudo");
+
+export class SudoService {
+  #shell: ShellService;
+
+  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 passwordPrompt({
+      message: "Enter sudo password to manage hosts",
+      mask: true,
+      validate: async (value) => {
+        debug("Attempting sudo authentication %o", { intent });
+
+        const output = await this.#shell.$`echo "${value}" | sudo -S -v`.nothrow();
+        exitCode = output.exitCode;
+
+        debug("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);
+    }
+  }
+}