@vlandoss/localproxy 0.0.3 → 0.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vlandoss/localproxy",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "Simple local development proxy automation",
   "homepage": "https://github.com/variableland/dx/tree/main/packages/localproxy#readme",
   "bugs": {

package/src/commands/clean.ts

@@ -14,15 +14,17 @@ export function createCleanCommand({ caddyfilePath }: Context) {
     .description("clean up config files")
     .option("--verbose", "verbose mode, show background output", false)
     .action(async function cleanAction(options: CommandOptions) {
+      const { verbose } = options;
+
       const caddyService = new CaddyService(caddyfilePath);
-      await caddyService.stop(options);
+      await caddyService.stop({ verbose });
 
       const caddyfileService = new CaddyfileService(caddyfilePath);
       const localDomains = await caddyfileService.getLocalDomains();
-      const hosts = localDomains.map((d) => d.host);
+      const hostnames = localDomains.map((d) => d.hostname);
 
-      const hostsService = new HostsService(hosts);
-      await hostsService.clean(options);
+      const hostsService = new HostsService();
+      await hostsService.clean({ verbose, hostnames });
 
       logger.success("Clean completed!");
     });

package/src/commands/setup.ts

@@ -47,7 +47,7 @@ export function createSetupCommand({ binDir, installDir, caddyfilePath }: Contex
     .description("setup config files")
     .option("--verbose", "verbose mode, show background output", false)
     .action(async function setupAction(options: CommandOptions) {
-      debug("setup command options %o", options);
+      const { verbose } = options;
 
       await checkInternalTools();
 
@@ -71,15 +71,14 @@ export function createSetupCommand({ binDir, installDir, caddyfilePath }: Contex
       await fileService.print();
 
       const caddyService = new CaddyService(caddyfilePath);
-      await caddyService.reboot(options);
+      await caddyService.reboot({ verbose });
 
       const caddyfileService = new CaddyfileService(caddyfilePath);
-
       const localDomains = await caddyfileService.getLocalDomains();
-      const hosts = localDomains.map((d) => d.host);
+      const hostnames = localDomains.map((d) => d.hostname);
 
-      const hostsService = new HostsService(hosts);
-      await hostsService.setup(options);
+      const hostsService = new HostsService();
+      await hostsService.setup({ verbose, hostnames });
 
       logger.success("Setup completed!");
     });

package/src/commands/status.ts

@@ -23,21 +23,19 @@ export function createStatusCommand({ caddyfilePath }: Context) {
 
       const caddyfileService = new CaddyfileService(caddyfilePath);
       const localDomains = await caddyfileService.getLocalDomains();
-      const hosts = localDomains.map((d) => d.host);
 
-      const hostsService = new HostsService(hosts);
+      const hostsService = new HostsService();
+      const enabledHosts = await hostsService.getEnabledHosts();
 
-      for (const domain of localDomains) {
-        const { host, ports } = domain;
-
-        const found = await hostsService.findHost(host);
+      localDomains.forEach(({ hostname, ports }) => {
+        const enabled = enabledHosts.some((h) => h.hostname === hostname);
         const formattedPorts = ports.map((p) => `:${p}`).join(", ");
 
-        if (found) {
-          logger.success("`%s` is configured -> %s", host, formattedPorts);
+        if (enabled) {
+          logger.success("`%s` is configured -> %s", hostname, formattedPorts);
         } else {
-          logger.warn("`%s` is not configured -> %s", host, formattedPorts);
+          logger.warn("`%s` is not configured -> %s", hostname, formattedPorts);
         }
-      }
+      });
     });
 }

package/src/services/caddyfile/service.ts

@@ -5,7 +5,7 @@ import { CaddyfileParser } from "./parser";
 const debug = logger.subdebug("caddyfile-service");
 
 export type LocalDomain = {
-  host: string;
+  hostname: string;
   ports: string[];
 };
 
@@ -33,7 +33,7 @@ export class CaddyfileService {
         .map((arg) => arg.split(":")[1] as string);
 
       return block.sites.map((site) => {
-        return { host: site, ports };
+        return { hostname: site, ports };
       });
     });
 

package/src/services/hosts.ts

@@ -4,16 +4,20 @@ import { SudoService } from "./sudo";
 
 type SetupOptions = {
   verbose: boolean;
+  hostnames: string[];
+};
+
+type Host = {
+  ip: string;
+  hostname: string;
 };
 
 const debug = logger.subdebug("hosts");
 
 export class HostsService {
-  #hosts: string[];
   #sudo: SudoService;
 
-  constructor(domains: string[]) {
-    this.#hosts = domains;
+  constructor() {
     this.#sudo = new SudoService();
   }
 
@@ -22,6 +26,8 @@ export class HostsService {
   }
 
   async setup(options: SetupOptions) {
+    const { hostnames } = options;
+
     logger.start("Setting up hosts");
 
     await this.#sudo.auth();
@@ -30,7 +36,7 @@ export class HostsService {
 
     await $`sudo hosts backups create`;
 
-    for (const host of this.#hosts) {
+    for (const host of hostnames) {
       await this.addHost(host, options);
     }
 
@@ -38,9 +44,11 @@ export class HostsService {
   }
 
   async clean(options: SetupOptions) {
+    const { hostnames } = options;
+
     await this.#sudo.auth();
 
-    for (const host of this.#hosts) {
+    for (const host of hostnames) {
       await this.removeHost(host, options);
     }
   }
@@ -71,4 +79,23 @@ export class HostsService {
       await $`sudo hosts remove ${host}`;
     }
   }
+
+  async getEnabledHosts(): Promise<Host[]> {
+    const output = await quietShell.$`hosts list enabled`.text();
+
+    const hosts = output
+      .split("\n")
+      .map((line) => {
+        const [ip, hostname] = line.split(/\s+/);
+
+        if (!ip || !hostname) {
+          return null;
+        }
+
+        return { ip, hostname };
+      })
+      .filter(Boolean);
+
+    return hosts as Host[];
+  }
 }