@vlandoss/localproxy 0.0.2-git-b8d71ee.0 → 0.0.2-git-62e4f21.0

package/package.json

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

package/src/commands/clean.ts

@@ -1,4 +1,3 @@
-import { password as passwordPrompt } from "@inquirer/prompts";
 import { createCommand } from "commander";
 import { CaddyService } from "~/services/caddy";
 import { HostsService } from "~/services/hosts";
@@ -13,20 +12,16 @@ 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);
 
       const localDomains = caddyService.getLocalDomains();
       const hosts = localDomains.map((d) => d.host);
 
-      const password = await passwordPrompt({
-        message: "sudo password to manage hosts",
-      });
-
       const hostsService = new HostsService(hosts);
-      await hostsService.clean({ ...options, password });
+      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 as editorPrompt, password as passwordPrompt } 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();
@@ -80,13 +80,9 @@ export function createSetupCommand({ binDir, installDir, caddyfilePath }: Contex
       const localDomains = caddyService.getLocalDomains();
       const hosts = localDomains.map((d) => d.host);
 
-      const password = await passwordPrompt({
-        message: "sudo password to manage hosts",
-      });
-
       const hostsService = new HostsService(hosts);
-      await hostsService.setup({ ...options, password });
+      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,6 +57,11 @@ 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 {
@@ -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,50 +1,44 @@
 import { logger } from "./logger";
 import { quietShell, silentShell, verboseShell } from "./shell";
+import { SudoService } from "./sudo";
 
 type SetupOptions = {
   verbose: boolean;
-  password: string;
 };
 
 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) {
     return verbose ? verboseShell : silentShell;
   }
 
-  async #auth(password: string) {
-    if (!password) {
-      throw new Error("Password is required");
-    }
+  async setup(options: SetupOptions) {
+    logger.start("Setting up hosts");
 
-    // Asking sudo directly in JS is unreliable,
-    // so we do it through a shell command
-    await silentShell.child({
-      stdio: ["ignore", "ignore", "pipe"],
-    }).$`echo "${password}" | sudo -S -v`;
-  }
+    await this.#sudo.auth();
 
-  async setup(options: SetupOptions) {
-    await this.#auth(options.password);
+    const { $ } = this.#shell(options);
 
-    const { stdout } = await verboseShell.$`sudo hosts backups create`;
-    const backupPath = stdout.match(/(\/[^\s]+)/)?.[1];
-    debug("Backup created at %s", backupPath);
+    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.#auth(options.password);
+    await this.#sudo.auth();
 
     for (const host of this.#hosts) {
       await this.removeHost(host, options);
@@ -53,8 +47,9 @@ export class HostsService {
 
   async findHost(host: string) {
     const { exitCode } = await quietShell.$`hosts show "${host}"`.nothrow();
-    debug("Host %s is %s", host, !exitCode ? "present" : "absent");
-    return !exitCode;
+    const found = exitCode === 0;
+    debug("Host %s is %s", host, found ? "present" : "absent");
+    return found;
   }
 
   async addHost(host: string, options: SetupOptions) {

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);
+    }
+  }
+}