vite-plugin-caddy-multiple-tls 0.0.1

package/README.md

@@ -0,0 +1,28 @@
+# vite-plugin-caddy-multiple-tls
+
+Vite plugin that runs Caddy to proxy local development traffic over HTTPS with
+derived domains like `<repo>.<branch>.localhost`.
+
+## Install
+
+```sh
+npm install -D vite-plugin-caddy-multiple-tls
+```
+
+## Usage
+
+```js
+import { defineConfig } from 'vite';
+import caddyTls from 'vite-plugin-caddy-multiple-tls';
+
+export default defineConfig({
+  plugins: [caddyTls()],
+});
+```
+
+## Options
+
+- `domain`: explicit domain to proxy without repo/branch derivation
+- `baseDomain`: base domain to build `<repo>.<branch>.<baseDomain>` (defaults to `localhost`)
+- `repo`, `branch`: override repo/branch names used for derived domains
+- `internalTls`: use Caddy internal CA for provided domains

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+import { PluginOption } from 'vite';
+
+interface ViteCaddyTlsPluginOptions {
+    /** Explicit domain to proxy without repo/branch derivation */
+    domain?: string;
+    /** Base domain to build <repo>.<branch>.<baseDomain> (defaults to localhost) */
+    baseDomain?: string;
+    /** Override repo name used in derived domains */
+    repo?: string;
+    /** Override branch name used in derived domains */
+    branch?: string;
+    cors?: string;
+    /** Override the default Caddy server name (srv0) */
+    serverName?: string;
+    /** Use Caddy's internal CA for the provided domains (defaults to true when baseDomain or domain is set) */
+    internalTls?: boolean;
+}
+/**
+ * Vite plugin to run Caddy server to proxy traffic on https for local development
+ *
+ * @param {@link ViteCaddyTlsPluginOptions} config - the config to pass to the plugin
+ * @example
+ * ```
+ * caddyTls({
+ *   domain: "app.localhost",
+ * })
+ * ```
+ * @returns {Plugin} - a Vite plugin
+ */
+declare function viteCaddyTlsPlugin({ domain, baseDomain, repo, branch, cors, serverName, internalTls, }?: ViteCaddyTlsPluginOptions): PluginOption;
+
+export { type ViteCaddyTlsPluginOptions, viteCaddyTlsPlugin as default };

package/dist/index.js

@@ -0,0 +1,460 @@
+// src/index.ts
+import chalk from "chalk";
+import { execSync as execSync2 } from "child_process";
+import path from "path";
+
+// src/utils.ts
+import { execSync } from "child_process";
+var CADDY_API = "http://localhost:2019";
+var DEFAULT_SERVER_NAME = "srv0";
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function parseConfig(text) {
+  if (!text.trim()) return {};
+  try {
+    return JSON.parse(text);
+  } catch (e) {
+    return void 0;
+  }
+}
+function isTlsPolicyOverlapError(text) {
+  return text.includes("cannot apply more than one automation policy to host");
+}
+function validateCaddyIsInstalled() {
+  try {
+    execSync("caddy version");
+    return true;
+  } catch (e) {
+    console.error("caddy cli is not installed");
+    return false;
+  }
+}
+async function isCaddyRunning() {
+  try {
+    const res = await fetch(`${CADDY_API}/config/`);
+    return res.ok;
+  } catch (e) {
+    return false;
+  }
+}
+async function startCaddy() {
+  try {
+    execSync("caddy start", { stdio: "ignore" });
+    for (let i = 0; i < 10; i++) {
+      if (await isCaddyRunning()) return true;
+      await new Promise((r) => setTimeout(r, 500));
+    }
+    return false;
+  } catch (e) {
+    console.error("Failed to start Caddy:", e);
+    return false;
+  }
+}
+async function ensureBaseConfig(serverName = DEFAULT_SERVER_NAME) {
+  const serverUrl = `${CADDY_API}/config/apps/http/servers/${serverName}`;
+  const res = await fetch(serverUrl);
+  if (res.ok) return;
+  const baseConfig = {
+    listen: [":443"],
+    routes: []
+  };
+  const httpAppConfig = {
+    servers: {
+      [serverName]: baseConfig
+    }
+  };
+  const configRes = await fetch(`${CADDY_API}/config/`);
+  if (!configRes.ok) {
+    const text = await configRes.text();
+    throw new Error(`Failed to read Caddy config: ${text}`);
+  }
+  const configText = await configRes.text();
+  const config = parseConfig(configText);
+  if (config === void 0) {
+    throw new Error("Failed to parse Caddy config response.");
+  }
+  const isEmptyConfig = configText.trim() === "" || config === null || isRecord(config) && Object.keys(config).length === 0;
+  if (isEmptyConfig) {
+    const loadRes = await fetch(`${CADDY_API}/load`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        apps: {
+          http: httpAppConfig
+        }
+      })
+    });
+    if (!loadRes.ok) {
+      const text = await loadRes.text();
+      throw new Error(`Failed to initialize Caddy base configuration: ${text}`);
+    }
+    return;
+  }
+  const apps = isRecord(config) ? config.apps : void 0;
+  const http = isRecord(apps) ? apps.http : void 0;
+  const servers = isRecord(http) ? http.servers : void 0;
+  let hasApps = isRecord(apps);
+  let hasHttp = isRecord(http);
+  let hasServers = isRecord(servers);
+  if (!hasApps) {
+    const createAppsRes = await fetch(`${CADDY_API}/config/apps`, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({})
+    });
+    if (!createAppsRes.ok && createAppsRes.status !== 409) {
+      const text = await createAppsRes.text();
+      throw new Error(`Failed to initialize Caddy base configuration: ${text}`);
+    }
+    hasApps = true;
+  }
+  if (!hasHttp) {
+    const createHttpRes = await fetch(`${CADDY_API}/config/apps/http`, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ servers: {} })
+    });
+    if (!createHttpRes.ok && createHttpRes.status !== 409) {
+      const text = await createHttpRes.text();
+      throw new Error(`Failed to initialize Caddy base configuration: ${text}`);
+    }
+    hasHttp = true;
+    hasServers = true;
+  }
+  if (!hasServers) {
+    const createServersRes = await fetch(`${CADDY_API}/config/apps/http/servers`, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({})
+    });
+    if (!createServersRes.ok && createServersRes.status !== 409) {
+      const text = await createServersRes.text();
+      throw new Error(`Failed to initialize Caddy base configuration: ${text}`);
+    }
+  }
+  const createServerRes = await fetch(serverUrl, {
+    method: "PUT",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(baseConfig)
+  });
+  if (!createServerRes.ok && createServerRes.status !== 409) {
+    const text = await createServerRes.text();
+    throw new Error(`Failed to initialize Caddy base configuration: ${text}`);
+  }
+}
+async function ensureTlsAutomation() {
+  const policiesUrl = `${CADDY_API}/config/apps/tls/automation/policies`;
+  const policiesRes = await fetch(policiesUrl);
+  if (policiesRes.ok) return;
+  const policiesText = await policiesRes.text();
+  if (policiesRes.status !== 404 && !policiesText.includes("invalid traversal path")) {
+    throw new Error(
+      `Failed to initialize Caddy TLS automation: ${policiesText}`
+    );
+  }
+  const automationRes = await fetch(`${CADDY_API}/config/apps/tls/automation`, {
+    method: "PUT",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ policies: [] })
+  });
+  if (automationRes.ok || automationRes.status === 409) return;
+  const automationText = await automationRes.text();
+  if (!automationText.includes("invalid traversal path")) {
+    throw new Error(
+      `Failed to initialize Caddy TLS automation: ${automationText}`
+    );
+  }
+  const tlsRes = await fetch(`${CADDY_API}/config/apps/tls`, {
+    method: "PUT",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ automation: { policies: [] } })
+  });
+  if (!tlsRes.ok && tlsRes.status !== 409) {
+    const text = await tlsRes.text();
+    throw new Error(`Failed to initialize Caddy TLS automation: ${text}`);
+  }
+}
+async function addRoute(id, domains, port, cors, serverName = DEFAULT_SERVER_NAME) {
+  const handlers = [];
+  if (cors) {
+    handlers.push({
+      handler: "headers",
+      response: {
+        set: {
+          "Access-Control-Allow-Origin": [cors],
+          "Access-Control-Allow-Methods": [
+            "GET",
+            "POST",
+            "PUT",
+            "PATCH",
+            "DELETE",
+            "OPTIONS"
+          ],
+          "Access-Control-Allow-Headers": ["*"]
+        }
+      }
+    });
+  }
+  handlers.push({
+    handler: "reverse_proxy",
+    upstreams: [{ dial: `localhost:${port}` }]
+  });
+  const route = {
+    "@id": id,
+    match: [{ host: domains }],
+    handle: [
+      {
+        handler: "subroute",
+        routes: [
+          {
+            handle: handlers
+          }
+        ]
+      }
+    ],
+    terminal: true
+  };
+  const res = await fetch(
+    `${CADDY_API}/config/apps/http/servers/${serverName}/routes`,
+    {
+      method: "POST",
+      // Append to routes list
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(route)
+    }
+  );
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Failed to add route: ${text}`);
+  }
+}
+async function addTlsPolicy(id, domains) {
+  await ensureTlsAutomation();
+  const policy = {
+    "@id": id,
+    subjects: domains,
+    issuers: [
+      {
+        module: "internal"
+      }
+    ]
+  };
+  const res = await fetch(`${CADDY_API}/config/apps/tls/automation/policies`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(policy)
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    if (isTlsPolicyOverlapError(text)) {
+      return;
+    }
+    throw new Error(`Failed to add TLS policy: ${text}`);
+  }
+}
+async function removeRoute(id) {
+  const res = await fetch(`${CADDY_API}/id/${id}`, {
+    method: "DELETE"
+  });
+  if (!res.ok && res.status !== 404) {
+    console.error(`Failed to remove route ${id}`);
+  }
+}
+async function removeTlsPolicy(id) {
+  const res = await fetch(`${CADDY_API}/id/${id}`, {
+    method: "DELETE"
+  });
+  if (!res.ok && res.status !== 404) {
+    console.error(`Failed to remove TLS policy ${id}`);
+  }
+}
+
+// src/index.ts
+function execGit(command) {
+  return execSync2(command, { stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
+}
+function getGitRepoInfo() {
+  const info = {};
+  try {
+    const repoRoot = execGit("git rev-parse --show-toplevel");
+    if (repoRoot) {
+      info.repo = path.basename(repoRoot);
+    }
+  } catch (e) {
+  }
+  try {
+    let branch = execGit("git rev-parse --abbrev-ref HEAD");
+    if (branch === "HEAD") {
+      branch = execGit("git rev-parse --short HEAD");
+    }
+    if (branch) {
+      info.branch = branch;
+    }
+  } catch (e) {
+  }
+  return info;
+}
+function normalizeBaseDomain(baseDomain) {
+  return baseDomain.trim().replace(/^\.+|\.+$/g, "").toLowerCase();
+}
+function sanitizeDomainLabel(value) {
+  return value.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+}
+function buildDerivedDomain(options) {
+  const baseDomain = normalizeBaseDomain(options.baseDomain ?? "localhost");
+  if (!baseDomain) return null;
+  let repo = options.repo;
+  let branch = options.branch;
+  if (!repo || !branch) {
+    const info = getGitRepoInfo();
+    if (!repo) repo = info.repo;
+    if (!branch) branch = info.branch;
+  }
+  if (!repo || !branch) return null;
+  const repoLabel = sanitizeDomainLabel(repo);
+  const branchLabel = sanitizeDomainLabel(branch);
+  if (!repoLabel || !branchLabel) return null;
+  return `${repoLabel}.${branchLabel}.${baseDomain}`;
+}
+function normalizeDomain(domain) {
+  const trimmed = domain.trim().toLowerCase();
+  if (!trimmed) return null;
+  return trimmed;
+}
+function resolveDomain(options) {
+  if (options.domain) {
+    return normalizeDomain(options.domain);
+  }
+  return buildDerivedDomain(options);
+}
+function viteCaddyTlsPlugin({
+  domain,
+  baseDomain,
+  repo,
+  branch,
+  cors,
+  serverName,
+  internalTls
+} = {}) {
+  return {
+    name: "vite:caddy-tls",
+    configureServer({ httpServer, config }) {
+      const fallbackPort = config.server.port || 5173;
+      const resolvedDomain = resolveDomain({ domain, baseDomain, repo, branch });
+      const domainArray = resolvedDomain ? [resolvedDomain] : [];
+      const routeId = `vite-proxy-${Date.now()}-${Math.floor(Math.random() * 1e3)}`;
+      const shouldUseInternalTls = internalTls ?? (baseDomain !== void 0 || domain !== void 0);
+      const tlsPolicyId = shouldUseInternalTls ? `${routeId}-tls` : null;
+      let cleanupStarted = false;
+      if (domainArray.length === 0) {
+        console.error(
+          chalk.red(
+            "No domain resolved. Provide domain, or run inside a git repo, or pass repo/branch."
+          )
+        );
+        return;
+      }
+      let tlsPolicyAdded = false;
+      function getServerPort() {
+        if (!httpServer) return fallbackPort;
+        const address = httpServer.address();
+        if (address && typeof address === "object" && "port" in address) {
+          return address.port;
+        }
+        return fallbackPort;
+      }
+      async function cleanupRoute() {
+        if (cleanupStarted) return;
+        cleanupStarted = true;
+        if (tlsPolicyId) {
+          await removeTlsPolicy(tlsPolicyId);
+        }
+        await removeRoute(routeId);
+      }
+      function onServerClose() {
+        void cleanupRoute();
+      }
+      function handleSignal(signal) {
+        process.off("SIGINT", onSigint);
+        process.off("SIGTERM", onSigterm);
+        void cleanupRoute().finally(() => {
+          process.kill(process.pid, signal);
+        });
+      }
+      function onSigint() {
+        handleSignal("SIGINT");
+      }
+      function onSigterm() {
+        handleSignal("SIGTERM");
+      }
+      function registerProcessCleanup() {
+        process.once("SIGINT", onSigint);
+        process.once("SIGTERM", onSigterm);
+      }
+      async function setupRoute() {
+        if (!validateCaddyIsInstalled()) {
+          return;
+        }
+        let running = await isCaddyRunning();
+        if (!running) {
+          running = await startCaddy();
+          if (!running) {
+            console.error(chalk.red("Failed to start Caddy server."));
+            return;
+          }
+        }
+        try {
+          await ensureBaseConfig(serverName);
+        } catch (e) {
+          console.error(chalk.red("Failed to configure Caddy base settings."), e);
+          return;
+        }
+        const port = getServerPort();
+        if (tlsPolicyId) {
+          try {
+            await addTlsPolicy(tlsPolicyId, domainArray);
+            tlsPolicyAdded = true;
+          } catch (e) {
+            console.error(chalk.red("Failed to add TLS policy to Caddy."), e);
+            return;
+          }
+        }
+        try {
+          await addRoute(routeId, domainArray, port, cors, serverName);
+        } catch (e) {
+          if (tlsPolicyAdded && tlsPolicyId) {
+            await removeTlsPolicy(tlsPolicyId);
+          }
+          console.error(chalk.red("Failed to add route to Caddy."), e);
+          return;
+        }
+        console.log();
+        console.log(chalk.green("\u{1F512} Caddy is proxying your traffic on https"));
+        console.log();
+        console.log(
+          `\u{1F517} Access your local ${domainArray.length > 1 ? "servers" : "server"} `
+        );
+        domainArray.forEach((domain2) => {
+          console.log(chalk.blue(`\u{1F30D} https://${domain2}`));
+        });
+        console.log();
+        registerProcessCleanup();
+        httpServer?.once("close", onServerClose);
+      }
+      function onListening() {
+        void setupRoute();
+      }
+      if (httpServer?.listening) {
+        void setupRoute();
+      } else if (httpServer) {
+        httpServer.once("listening", onListening);
+      } else {
+        void setupRoute();
+      }
+    }
+  };
+}
+export {
+  viteCaddyTlsPlugin as default
+};

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "vite-plugin-caddy-multiple-tls",
+  "version": "0.0.1",
+  "description": "Vite plugin that uses Caddy to provide local HTTPS with derived domains.",
+  "keywords": [
+    "vite",
+    "plugin",
+    "caddy",
+    "https",
+    "tls",
+    "local-development"
+  ],
+  "license": "MIT",
+  "author": "vampaz",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "dev": "tsup --watch src/**/* src/index.ts --format esm --dts-resolve",
+    "build": "tsup src/index.ts --format esm --dts",
+    "prepublishOnly": "npm run build",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vampaz/vite-plugin-caddy-multiple-tls.git"
+  },
+  "bugs": {
+    "url": "https://github.com/vampaz/vite-plugin-caddy-multiple-tls/issues"
+  },
+  "homepage": "https://github.com/vampaz/vite-plugin-caddy-multiple-tls/#readme",
+  "peerDependencies": {
+    "vite": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^25.0.3",
+    "fs-extra": "^11.3.3",
+    "tsup": "^8.5.1",
+    "vite": "^7.3.0",
+    "vitest": "^4.0.16"
+  },
+  "dependencies": {
+    "chalk": "^5.6.2"
+  }
+}