@vlandoss/localproxy 0.0.2 → 0.0.3

package/README.md

@@ -28,7 +28,7 @@ http://admin.localhost
 pnpm add -g @vlandoss/localproxy
 ```
 
-It will adds the `localproxy` to your global workspace
+It will adds the `localp` CLI to your global workspace
 
 ## Usage
 
@@ -38,7 +38,7 @@ It will adds the `localproxy` to your global workspace
 Run the help command:
 
 ```sh
-localproxy help
+localp help
 ```
 
 ## Troubleshooting
@@ -46,5 +46,5 @@ localproxy help
 To enable debug mode, set the `DEBUG` environment variable to `localproxy:*` before running *any* command.
 
 ```sh
-DEBUG=localproxy:* localproxy <command>
+DEBUG=localproxy:* localp <command>
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vlandoss/localproxy",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "Simple local development proxy automation",
   "homepage": "https://github.com/variableland/dx/tree/main/packages/localproxy#readme",
   "bugs": {
@@ -34,5 +34,8 @@
   },
   "engines": {
     "bun": ">=1.0.0"
+  },
+  "scripts": {
+    "test": "vitest run"
   }
 }

package/src/commands/clean.ts

@@ -1,5 +1,6 @@
 import { createCommand } from "commander";
 import { CaddyService } from "~/services/caddy";
+import { CaddyfileService } from "~/services/caddyfile";
 import { HostsService } from "~/services/hosts";
 import { logger } from "~/services/logger";
 import type { Context } from "~/types";
@@ -16,7 +17,8 @@ export function createCleanCommand({ caddyfilePath }: Context) {
       const caddyService = new CaddyService(caddyfilePath);
       await caddyService.stop(options);
 
-      const localDomains = caddyService.getLocalDomains();
+      const caddyfileService = new CaddyfileService(caddyfilePath);
+      const localDomains = await caddyfileService.getLocalDomains();
       const hosts = localDomains.map((d) => d.host);
 
       const hostsService = new HostsService(hosts);

package/src/commands/setup.ts

@@ -3,6 +3,8 @@ import path from "node:path";
 import { editor as editorPrompt } from "@inquirer/prompts";
 import { createCommand } from "commander";
 import { CaddyService } from "~/services/caddy";
+import { CaddyfileService } from "~/services/caddyfile";
+import { FileService } from "~/services/file";
 import { HostsService } from "~/services/hosts";
 import { logger } from "~/services/logger";
 import { quietShell } from "~/services/shell";
@@ -14,13 +16,6 @@ type CommandOptions = {
 
 const debug = logger.subdebug("setup");
 
-async function printFile(filePath: string) {
-  const fileContent = (await fs.readFile(filePath)).toString();
-
-  console.log(`${filePath}:\n`);
-  console.log(fileContent.trim());
-}
-
 async function checkInternalTools() {
   const { $ } = quietShell;
 
@@ -72,12 +67,15 @@ export function createSetupCommand({ binDir, installDir, caddyfilePath }: Contex
 
       await fs.writeFile(caddyfilePath, fileContent);
 
-      await printFile(caddyfilePath);
+      const fileService = new FileService(caddyfilePath);
+      await fileService.print();
 
       const caddyService = new CaddyService(caddyfilePath);
       await caddyService.reboot(options);
 
-      const localDomains = caddyService.getLocalDomains();
+      const caddyfileService = new CaddyfileService(caddyfilePath);
+
+      const localDomains = await caddyfileService.getLocalDomains();
       const hosts = localDomains.map((d) => d.host);
 
       const hostsService = new HostsService(hosts);

package/src/commands/status.ts

@@ -1,5 +1,7 @@
 import { createCommand } from "commander";
 import { CaddyService } from "~/services/caddy";
+import { CaddyfileService } from "~/services/caddyfile";
+import { FileService } from "~/services/file";
 import { HostsService } from "~/services/hosts";
 import { logger } from "~/services/logger";
 import type { Context } from "~/types";
@@ -16,19 +18,25 @@ export function createStatusCommand({ caddyfilePath }: Context) {
         logger.warn("Caddy is not running. Use `localp start` to start it.");
       }
 
-      const localDomains = caddyService.getLocalDomains();
+      const fileService = new FileService(caddyfilePath);
+      await fileService.print();
+
+      const caddyfileService = new CaddyfileService(caddyfilePath);
+      const localDomains = await caddyfileService.getLocalDomains();
       const hosts = localDomains.map((d) => d.host);
 
       const hostsService = new HostsService(hosts);
 
       for (const domain of localDomains) {
-        const { host, port } = domain;
+        const { host, ports } = domain;
+
         const found = await hostsService.findHost(host);
+        const formattedPorts = ports.map((p) => `:${p}`).join(", ");
 
         if (found) {
-          logger.success("`%s` is configured -> :%s", host, port);
+          logger.success("`%s` is configured -> %s", host, formattedPorts);
         } else {
-          logger.warn("`%s` is not configured -> :%s", host, port);
+          logger.warn("`%s` is not configured -> %s", host, formattedPorts);
         }
       }
     });

package/src/services/caddy.ts

@@ -9,11 +9,6 @@ type ExecOption = {
   verbose: boolean;
 };
 
-export type LocalDomain = {
-  host: string;
-  port: string;
-};
-
 export class CaddyService {
   #configPath: string;
   #pidFilePath: string;
@@ -108,23 +103,4 @@ export class CaddyService {
 
     return isRunning;
   }
-
-  getLocalDomains(): LocalDomain[] {
-    const caddyfileContent = fs.readFileSync(this.#configPath, "utf-8");
-
-    const REGEX = /^(.+)\.localhost/gm;
-    const matches = caddyfileContent.matchAll(REGEX);
-
-    const hosts = Array.from(matches, (m) => m[0]).filter(Boolean) as string[];
-
-    const localDomains: LocalDomain[] = hosts.map((host) => {
-      const index = caddyfileContent.indexOf(host);
-      const port = caddyfileContent.slice(index).match(/localhost:(\d+)/)?.[1] || "80";
-      return { host, port };
-    });
-
-    debug("detected domains: %o", localDomains);
-
-    return localDomains;
-  }
 }

package/src/services/caddyfile/index.ts

@@ -0,0 +1 @@
+export * from "./service";

package/src/services/caddyfile/parser.ts

@@ -0,0 +1,123 @@
+type SiteBlock = {
+  sites: string[];
+  directives: Directive[];
+};
+
+type Directive = {
+  type: string;
+  matchToken?: string;
+  arguments: string[];
+};
+
+export type Caddyfile = {
+  siteBlocks: SiteBlock[];
+};
+
+export class CaddyfileParser {
+  #content: string;
+
+  constructor(content: string) {
+    this.#content = content;
+  }
+
+  parse(): Caddyfile {
+    const siteBlocks = this.#extractSiteBlocks(this.#content);
+
+    return {
+      siteBlocks,
+    };
+  }
+
+  #extractSiteBlocks(content: string) {
+    const siteBlocks: SiteBlock[] = [];
+
+    const bracedBlockRegex = /([^{]+)\s*\{([^}]*)\}/gs;
+
+    let match: RegExpExecArray | null | undefined;
+    const processedContent = new Set<string>();
+
+    // biome-ignore lint/suspicious/noAssignInExpressions: loop over content
+    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: string) {
+    if (!sitesStr.trim()) {
+      return [];
+    }
+
+    return sitesStr
+      .split(/[,\s]+/)
+      .map((site) => site.trim())
+      .filter((site) => site.length > 0);
+  }
+
+  #parseDirectives(directivesStr: string) {
+    const directives: Directive[] = [];
+
+    if (!directivesStr.trim()) {
+      return directives;
+    }
+
+    // Split into lines and process each directive
+    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: string): Directive | null {
+    // Simple regex to parse: directive [matcher] arg1 arg2 ...
+    const directiveRegex = /^(\w+)(?:\s+(.+))?$/;
+    const match = line.match(directiveRegex);
+
+    if (!match) {
+      return null;
+    }
+
+    const [, directiveType, argsStr] = match;
+
+    const directive: Directive = {
+      type: directiveType as string,
+      arguments: [],
+    };
+
+    if (argsStr) {
+      const args = argsStr.split(/\s+/).filter((arg) => arg.length > 0);
+
+      if (args.length > 0 && this.#looksLikeMatcher(args[0] as string)) {
+        directive.matchToken = args[0];
+        directive.arguments = args.slice(1);
+      } else {
+        directive.arguments = args;
+      }
+    }
+
+    return directive;
+  }
+
+  #looksLikeMatcher(token: string) {
+    return token === "*" || token.startsWith("/") || token.startsWith("@");
+  }
+}

package/src/services/caddyfile/service.ts

@@ -0,0 +1,48 @@
+import * as fs from "node:fs/promises";
+import { logger } from "../logger";
+import { CaddyfileParser } from "./parser";
+
+const debug = logger.subdebug("caddyfile-service");
+
+export type LocalDomain = {
+  host: string;
+  ports: string[];
+};
+
+const LOCALHOST_REGEX = /localhost(:\d+)?/;
+
+export class CaddyfileService {
+  #filepath: string;
+
+  constructor(filepath: string) {
+    this.#filepath = filepath;
+  }
+
+  async getLocalDomains(): Promise<LocalDomain[]> {
+    const caddyfileContent = await fs.readFile(this.#filepath, "utf-8");
+
+    const caddyfileParser = new CaddyfileParser(caddyfileContent);
+
+    const caddyfile = caddyfileParser.parse();
+
+    const domains = caddyfile.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] as string);
+
+      return block.sites.map((site) => {
+        return { host: site, ports };
+      });
+    });
+
+    debug("detected domains: %o", domains);
+
+    return domains;
+  }
+
+  #isLocalhost(arg: string) {
+    return LOCALHOST_REGEX.test(arg);
+  }
+}

package/src/services/file.ts

@@ -0,0 +1,16 @@
+import fs from "node:fs/promises";
+
+export class FileService {
+  #filePath: string;
+
+  constructor(filePath: string) {
+    this.#filePath = filePath;
+  }
+
+  async print() {
+    const fileContent = (await fs.readFile(this.#filePath)).toString();
+
+    console.log(`${this.#filePath}:\n`);
+    console.log(fileContent.trim());
+  }
+}