@hamedb89/localghost 0.1.10 → 0.1.13

package/dist/{tunnel-DzfLXZ8O.d.ts → tunnel-BA52DD9e.d.ts}

@@ -55,6 +55,51 @@ type GhostTunnelPreviewOptions = {
 };
 type GhostTunnelMode = "manual" | "public";
 type GhostTunnelDomainOptions = string | readonly string[];
+type GhostTunnelAdapterProvider = "vercel";
+type GhostTunnelAdapterStrategy = "same-project" | "separate-relay";
+type GhostTunnelTransportKind = "none" | "ip" | "tunnel";
+type GhostTunnelAdapterTransport = GhostTunnelTransportKind;
+type GhostTunnelTunnelStoreProvider = "vercel-redis" | "redis";
+type GhostTunnelTunnelStoreEnv = "auto";
+type GhostTunnelTunnelStoreOptions = {
+    provider?: GhostTunnelTunnelStoreProvider;
+    env?: GhostTunnelTunnelStoreEnv;
+    namespace?: string;
+};
+type GhostTunnelTransportOptions = GhostTunnelTransportKind | {
+    kind?: "none";
+} | {
+    kind: "ip";
+    allowPrivateNetworkAddress?: boolean;
+} | {
+    kind: "tunnel";
+    store?: GhostTunnelTunnelStoreOptions;
+    waitMs?: number;
+    pollIntervalMs?: number;
+    routeTtlSeconds?: number;
+    requestTtlSeconds?: number;
+    maxRequestBodyBytes?: number;
+    maxResponseBodyBytes?: number;
+};
+type GhostTunnelTransportConfig = {
+    kind: "none";
+} | {
+    kind: "ip";
+    allowPrivateNetworkAddress: boolean;
+} | {
+    kind: "tunnel";
+    store: Required<Pick<GhostTunnelTunnelStoreOptions, "provider" | "env" | "namespace">>;
+    waitMs: number;
+    pollIntervalMs: number;
+    routeTtlSeconds: number;
+    requestTtlSeconds: number;
+    maxRequestBodyBytes: number;
+    maxResponseBodyBytes: number;
+};
+type GhostTunnelAdapterOptions = GhostTunnelAdapterProvider | {
+    provider: GhostTunnelAdapterProvider;
+    strategy?: GhostTunnelAdapterStrategy;
+};
 type GhostTunnelOptions = false | GhostTunnelMode | {
     enabled?: boolean;
     mode?: GhostTunnelMode;
@@ -64,6 +109,8 @@ type GhostTunnelOptions = false | GhostTunnelMode | {
     preview?: GhostTunnelPreviewOptions;
     requireHttps?: boolean;
     requireAuth?: boolean;
+    adapter?: GhostTunnelAdapterOptions;
+    transport?: GhostTunnelTransportOptions;
 };
 type GhostTunnelConfig = {
     enabled: boolean;
@@ -77,6 +124,11 @@ type GhostTunnelConfig = {
     displayUrls: string[];
     requireHttps: boolean;
     requireAuth: boolean;
+    transport: GhostTunnelTransportConfig;
+    adapter?: {
+        provider: GhostTunnelAdapterProvider;
+        strategy: GhostTunnelAdapterStrategy;
+    };
 };
 type GhostTunnelDisplayDefaults = {
     domain?: string;
@@ -123,4 +175,4 @@ declare function assertSecureGhostTunnelRequest(input: {
     authenticated?: boolean;
 }): GhostTunnelRoute;
 
-export { parseDevHosts as A, parseGhostTunnelHost as B, type ConfigPattern as C, type DevHostEntry as D, readDevHosts as E, resolveDevHostsPath as F, type GhostTunnelOptions as G, resolveGhostTunnelConfig as H, sanitizeProjectName as I, LOCALGHOST_CONFIG_FILE as L, type ReadDevHostsOptions as R, type GhostTunnelConfig as a, type ConstructGhostTunnelUrlInput as b, type GhostTunnelDisplayDefaults as c, type GhostTunnelDomainOptions as d, type GhostTunnelMode as e, type GhostTunnelNamespaceConfig as f, type GhostTunnelNamespaceOptions as g, type GhostTunnelNamespaceTag as h, type GhostTunnelNamespaceValues as i, type GhostTunnelPreviewOptions as j, type GhostTunnelRoute as k, type ResolvedDevHostsPath as l, assertSecureGhostTunnelRequest as m, constructGhostTunnelHost as n, constructGhostTunnelURL as o, constructGhostTunnelUrl as p, findLocalMdnsHosts as q, getConfigFileCandidates as r, getDevHostsPath as s, getGhostTunnelDefaultDisplayUrl as t, getGhostTunnelDisplayUrl as u, getGhostTunnelDisplayUrls as v, getGhostTunnelEntryHost as w, getGhostTunnelPreviewUrl as x, getGhostTunnelWildcardHost as y, getProjectName as z };
+export { findLocalMdnsHosts as A, getConfigFileCandidates as B, type ConfigPattern as C, type DevHostEntry as D, getDevHostsPath as E, getGhostTunnelDefaultDisplayUrl as F, type GhostTunnelOptions as G, getGhostTunnelDisplayUrl as H, getGhostTunnelDisplayUrls as I, getGhostTunnelEntryHost as J, getGhostTunnelPreviewUrl as K, LOCALGHOST_CONFIG_FILE as L, getGhostTunnelWildcardHost as M, getProjectName as N, parseDevHosts as O, parseGhostTunnelHost as P, readDevHosts as Q, type ReadDevHostsOptions as R, resolveDevHostsPath as S, resolveGhostTunnelConfig as T, sanitizeProjectName as U, type ResolvedDevHostsPath as a, type ConstructGhostTunnelUrlInput as b, type GhostTunnelTransportOptions as c, type GhostTunnelTransportConfig as d, type GhostTunnelRoute as e, type GhostTunnelConfig as f, type GhostTunnelAdapterOptions as g, type GhostTunnelAdapterProvider as h, type GhostTunnelAdapterStrategy as i, type GhostTunnelAdapterTransport as j, type GhostTunnelDisplayDefaults as k, type GhostTunnelDomainOptions as l, type GhostTunnelMode as m, type GhostTunnelNamespaceConfig as n, type GhostTunnelNamespaceOptions as o, type GhostTunnelNamespaceTag as p, type GhostTunnelNamespaceValues as q, type GhostTunnelPreviewOptions as r, type GhostTunnelTransportKind as s, type GhostTunnelTunnelStoreEnv as t, type GhostTunnelTunnelStoreOptions as u, type GhostTunnelTunnelStoreProvider as v, assertSecureGhostTunnelRequest as w, constructGhostTunnelHost as x, constructGhostTunnelURL as y, constructGhostTunnelUrl as z };

package/dist/vite.d.ts

@@ -1,5 +1,5 @@
 import { Plugin } from 'vite';
-import { C as ConfigPattern, G as GhostTunnelOptions } from './tunnel-DzfLXZ8O.js';
+import { C as ConfigPattern, G as GhostTunnelOptions } from './tunnel-BA52DD9e.js';
 
 type LocalGhostPluginOptions = {
     cwd?: string;
@@ -10,6 +10,7 @@ type LocalGhostPluginOptions = {
     https?: boolean;
     bindHost?: string | boolean;
     dynamicPort?: boolean;
+    autoRepair?: boolean;
     primaryHost?: string;
     log?: boolean;
     setup?: boolean | "prompt";

package/dist/vite.js

@@ -270,6 +270,17 @@ var DEFAULT_GHOST_TUNNEL_SUBDOMAIN = "ghost";
 var DEFAULT_GHOST_TUNNEL_NAMESPACE_TAGS = ["route", "project", "owner"];
 var DEFAULT_GHOST_TUNNEL_NAMESPACE_SEPARATOR = "-";
 var DEFAULT_GHOST_TUNNEL_MODE = "manual";
+var DEFAULT_GHOST_TUNNEL_ADAPTER_STRATEGY = "same-project";
+var DEFAULT_GHOST_TUNNEL_TRANSPORT_KIND = "none";
+var DEFAULT_GHOST_TUNNEL_TUNNEL_STORE_PROVIDER = "vercel-redis";
+var DEFAULT_GHOST_TUNNEL_TUNNEL_STORE_ENV = "auto";
+var DEFAULT_GHOST_TUNNEL_TUNNEL_STORE_NAMESPACE = "localghost";
+var DEFAULT_GHOST_TUNNEL_TUNNEL_WAIT_MS = 25e3;
+var DEFAULT_GHOST_TUNNEL_TUNNEL_POLL_INTERVAL_MS = 250;
+var DEFAULT_GHOST_TUNNEL_TUNNEL_ROUTE_TTL_SECONDS = 30;
+var DEFAULT_GHOST_TUNNEL_TUNNEL_REQUEST_TTL_SECONDS = 60;
+var DEFAULT_GHOST_TUNNEL_TUNNEL_MAX_REQUEST_BODY_BYTES = 1024 * 1024;
+var DEFAULT_GHOST_TUNNEL_TUNNEL_MAX_RESPONSE_BODY_BYTES = 5 * 1024 * 1024;
 function isResolvedGhostTunnelConfig(value) {
   return typeof value === "object" && value !== null && "enabled" in value;
 }
@@ -319,6 +330,86 @@ function normalizeDomains(domains) {
 function parseGhostTunnelMode(value) {
   return value ?? DEFAULT_GHOST_TUNNEL_MODE;
 }
+function parseGhostTunnelAdapterStrategy(value) {
+  if (typeof value === "undefined") return DEFAULT_GHOST_TUNNEL_ADAPTER_STRATEGY;
+  if (value === "same-project" || value === "separate-relay") return value;
+  throw new Error(`Unsupported ghost tunnel adapter strategy: ${String(value)}`);
+}
+function parseGhostTunnelTransportKind(value) {
+  if (typeof value === "undefined") return DEFAULT_GHOST_TUNNEL_TRANSPORT_KIND;
+  if (value === "none" || value === "ip" || value === "tunnel") return value;
+  throw new Error(`Unsupported ghost tunnel transport: ${String(value)}`);
+}
+function parsePositiveInteger(value, fallback, name) {
+  if (typeof value === "undefined") return fallback;
+  if (!Number.isInteger(value) || value < 1) {
+    throw new Error(`Invalid ghost tunnel ${name}: ${value}`);
+  }
+  return value;
+}
+function parseTunnelStoreProvider(value) {
+  if (typeof value === "undefined") return DEFAULT_GHOST_TUNNEL_TUNNEL_STORE_PROVIDER;
+  if (value === "vercel-redis" || value === "redis") return value;
+  throw new Error(`Unsupported ghost tunnel tunnel store provider: ${String(value)}`);
+}
+function parseTunnelStoreEnv(value) {
+  if (typeof value === "undefined") return DEFAULT_GHOST_TUNNEL_TUNNEL_STORE_ENV;
+  if (value === "auto") return value;
+  throw new Error(`Unsupported ghost tunnel tunnel store env: ${String(value)}`);
+}
+function parseTunnelStoreNamespace(value) {
+  const namespace = value ?? DEFAULT_GHOST_TUNNEL_TUNNEL_STORE_NAMESPACE;
+  if (!/^[a-z][a-z0-9:_-]{0,63}$/i.test(namespace)) {
+    throw new Error(`Invalid ghost tunnel tunnel store namespace: ${namespace}`);
+  }
+  return namespace;
+}
+function resolveGhostTunnelAdapter(input2) {
+  if (!input2) return void 0;
+  const provider = typeof input2 === "string" ? input2 : input2.provider;
+  if (provider !== "vercel") {
+    throw new Error(`Unsupported ghost tunnel adapter provider: ${String(provider)}`);
+  }
+  return {
+    provider,
+    strategy: typeof input2 === "string" ? DEFAULT_GHOST_TUNNEL_ADAPTER_STRATEGY : parseGhostTunnelAdapterStrategy(input2.strategy)
+  };
+}
+function getLegacyGhostTunnelTransport(input2) {
+  if (!input2 || typeof input2 === "string" || !("transport" in input2)) return void 0;
+  return input2.transport;
+}
+function resolveGhostTunnelTransport(input2) {
+  if (!input2) {
+    return { kind: "none" };
+  }
+  const kind = typeof input2 === "string" ? parseGhostTunnelTransportKind(input2) : parseGhostTunnelTransportKind(input2.kind);
+  if (kind === "ip") {
+    return {
+      kind,
+      allowPrivateNetworkAddress: typeof input2 === "string" ? false : input2.kind === "ip" ? input2.allowPrivateNetworkAddress ?? false : false
+    };
+  }
+  if (kind === "tunnel") {
+    const config = typeof input2 === "string" || input2.kind !== "tunnel" ? void 0 : input2;
+    const store = config?.store ?? {};
+    return {
+      kind,
+      store: {
+        provider: parseTunnelStoreProvider(store.provider),
+        env: parseTunnelStoreEnv(store.env),
+        namespace: parseTunnelStoreNamespace(store.namespace)
+      },
+      waitMs: parsePositiveInteger(config?.waitMs, DEFAULT_GHOST_TUNNEL_TUNNEL_WAIT_MS, "tunnel waitMs"),
+      pollIntervalMs: parsePositiveInteger(config?.pollIntervalMs, DEFAULT_GHOST_TUNNEL_TUNNEL_POLL_INTERVAL_MS, "tunnel pollIntervalMs"),
+      routeTtlSeconds: parsePositiveInteger(config?.routeTtlSeconds, DEFAULT_GHOST_TUNNEL_TUNNEL_ROUTE_TTL_SECONDS, "tunnel routeTtlSeconds"),
+      requestTtlSeconds: parsePositiveInteger(config?.requestTtlSeconds, DEFAULT_GHOST_TUNNEL_TUNNEL_REQUEST_TTL_SECONDS, "tunnel requestTtlSeconds"),
+      maxRequestBodyBytes: parsePositiveInteger(config?.maxRequestBodyBytes, DEFAULT_GHOST_TUNNEL_TUNNEL_MAX_REQUEST_BODY_BYTES, "tunnel maxRequestBodyBytes"),
+      maxResponseBodyBytes: parsePositiveInteger(config?.maxResponseBodyBytes, DEFAULT_GHOST_TUNNEL_TUNNEL_MAX_RESPONSE_BODY_BYTES, "tunnel maxResponseBodyBytes")
+    };
+  }
+  return { kind: "none" };
+}
 function resolveNamespaceConfig(options) {
   const tags = isNamespaceTagList(options) ? [...options] : [...options?.tags ?? DEFAULT_GHOST_TUNNEL_NAMESPACE_TAGS];
   let separator = DEFAULT_GHOST_TUNNEL_NAMESPACE_SEPARATOR;
@@ -404,11 +495,11 @@ function getDisplayValues(input2) {
     ...input2.values
   };
 }
-function getDisplayDefaults(config, defaults) {
-  return config.mode === "public" && !config.preview ? void 0 : defaults;
+function getDisplayDefaults(defaults) {
+  return defaults;
 }
 function createDisplayUrl(config, defaults, domain) {
-  const input2 = getPreviewDefaults(config.preview, getDisplayDefaults(config, defaults));
+  const input2 = getPreviewDefaults(config.preview, getDisplayDefaults(defaults));
   const protocol = input2.protocol ?? "https";
   const slug = createNamespaceDisplaySlug(config.namespace, getDisplayValues(input2));
   const entryHost = domain ? getGhostTunnelEntryHost(domain, config) : input2.domain ? getGhostTunnelEntryHost(input2.domain, config) : `${config.subdomain}.*`;
@@ -417,7 +508,7 @@ function createDisplayUrl(config, defaults, domain) {
   return `${url}${input2.path.replace(/^\/+/, "")}`;
 }
 function createDisplayUrls(config, defaults) {
-  const displayDefaults = getDisplayDefaults(config, defaults);
+  const displayDefaults = getDisplayDefaults(defaults);
   const domains = config.domains.length > 0 ? config.domains : displayDefaults?.domain ? [displayDefaults.domain] : [];
   const urls = domains.length > 0 ? domains.map((domain) => createDisplayUrl(config, displayDefaults, domain)) : [createDisplayUrl(config, displayDefaults)];
   return [...new Set(urls)];
@@ -447,7 +538,8 @@ function resolveGhostTunnelConfig(options, defaults) {
       namespace: resolveNamespaceConfig(void 0),
       displayUrls: [],
       requireHttps: true,
-      requireAuth: true
+      requireAuth: true,
+      transport: resolveGhostTunnelTransport(void 0)
     };
   }
   const config = typeof options === "string" ? { mode: options } : options;
@@ -455,6 +547,8 @@ function resolveGhostTunnelConfig(options, defaults) {
   assertValidSubdomain(subdomain);
   const domains = normalizeDomains(config.domains);
   const enabled = config.enabled ?? true;
+  const adapter = resolveGhostTunnelAdapter(config.adapter);
+  const transport = resolveGhostTunnelTransport(config.transport ?? getLegacyGhostTunnelTransport(config.adapter));
   const resolved = {
     enabled,
     mode: parseGhostTunnelMode(config.mode),
@@ -464,7 +558,9 @@ function resolveGhostTunnelConfig(options, defaults) {
     ...config.preview ? { preview: config.preview } : {},
     displayUrls: [],
     requireHttps: config.requireHttps ?? true,
-    requireAuth: config.requireAuth ?? true
+    requireAuth: config.requireAuth ?? true,
+    transport,
+    ...adapter ? { adapter } : {}
   };
   if (!enabled) {
     return resolved;
@@ -574,7 +670,7 @@ function withRuntimePort(entries, requestedPort, port) {
   if (requestedPort === port) return entries;
   const hasRequestedPort = entries.some((entry) => entry.port === requestedPort);
   if (!hasRequestedPort) return entries;
-  return entries.map((entry) => entry.port === requestedPort ? { ...entry, port } : entry);
+  return entries.map((entry) => entry.port === requestedPort ? { ...entry, port, target: `127.0.0.1:${port}` } : entry);
 }
 function uniqueHosts(entries) {
   return [...new Set(entries.map((entry) => entry.host))];
@@ -625,6 +721,7 @@ async function resolveLocalghostContext(options = {}) {
   const configEntries = readDevHosts(readOptions);
   const requestedPort = merged.port ?? envPort() ?? configEntries[0]?.port ?? 5173;
   const dynamicPort = merged.dynamicPort ?? envDynamicPort() ?? true;
+  const autoRepair = merged.autoRepair ?? true;
   const bindHost = merged.bindHost ?? "127.0.0.1";
   const probeHost = typeof bindHost === "string" ? bindHost : "127.0.0.1";
   const port = dynamicPort ? await findAvailablePort(requestedPort, { host: probeHost }) : requestedPort;
@@ -650,6 +747,7 @@ async function resolveLocalghostContext(options = {}) {
     requestedPort,
     port,
     dynamicPort,
+    autoRepair,
     bindHost,
     primaryHost,
     https: merged.https ?? envHttps() ?? false,
@@ -719,7 +817,8 @@ function getManagedBlockPattern(projectName) {
   const end = `# localghost:end ${sanitizedProjectName}`;
   return new RegExp(`${escapeRegExp(start)}[\\s\\S]*?${escapeRegExp(end)}\\n?`, "m");
 }
-function getSystemHostsPath() {
+function getSystemHostsPath(env = process.env) {
+  if (env.LOCALGHOST_HOSTS_PATH) return env.LOCALGHOST_HOSTS_PATH;
   return process.platform === "win32" ? "C:\\Windows\\System32\\drivers\\etc\\hosts" : "/etc/hosts";
 }
 function renderHostsBlock(projectName, entries) {
@@ -745,6 +844,10 @@ async function writeSystemHostsFile(hostsPath, next, projectName) {
   const sanitizedProjectName = sanitizeProjectName(projectName);
   const tempPath = join4(tmpdir(), `localghost-${sanitizedProjectName}-hosts`);
   writeFileSync3(tempPath, next, "utf8");
+  if (process.env.LOCALGHOST_HOSTS_PATH) {
+    writeFileSync3(hostsPath, next, "utf8");
+    return tempPath;
+  }
   if (process.platform === "win32") {
     throw new Error(`Windows support: run as administrator and copy ${tempPath} to ${hostsPath}.`);
   }
@@ -816,6 +919,12 @@ function writeLocalghostState(cwd, state) {
 // src/caddy.ts
 import { dirname as dirname3, join as join6 } from "path";
 import { execa as execa3 } from "execa";
+function shouldShowCaddyLogs() {
+  return ["1", "true", "yes", "on"].includes((process.env.LOCALGHOST_CADDY_VERBOSE ?? "").toLowerCase());
+}
+function caddyStdio() {
+  return shouldShowCaddyLogs() ? "inherit" : "pipe";
+}
 function groupByPort(entries) {
   const groups = /* @__PURE__ */ new Map();
   for (const entry of entries) {
@@ -834,7 +943,7 @@ function renderCaddyfile(entries, options = {}) {
   const blocks = [...groups.entries()].sort(([leftPort], [rightPort]) => leftPort - rightPort).map(([port, group]) => {
     const hosts = group.map((entry) => https ? entry.host : `http://${entry.host}`).sort().join(", ");
     return `${hosts} {
-  reverse_proxy 127.0.0.1:${port}
+	reverse_proxy 127.0.0.1:${port}
 }`;
   });
   const globalOptions = https ? `{
@@ -853,7 +962,7 @@ async function writeCaddyfile(entries, cwd = process.cwd(), options = {}) {
 async function validateCaddyfile(path) {
   await execa3("caddy", ["validate", "--config", path], {
     cwd: dirname3(path),
-    stdio: "inherit"
+    stdio: caddyStdio()
   });
 }
 
@@ -895,7 +1004,8 @@ function formatGhostTunnel(config, options = {}) {
   if (options.verbose) {
     lines.push(`  domains: ${config.domains.length > 0 ? config.domains.join(", ") : "*"}`);
     lines.push(`  access: ${config.requireAuth ? "auth required" : "app decides"}`);
-    lines.push(`  transport: ${config.requireHttps ? "https required" : "http allowed"}`);
+    lines.push(`  protocol: ${config.requireHttps ? "https required" : "http allowed"}`);
+    lines.push(`  transport: ${config.transport.kind}`);
   }
   return lines.join("\n");
 }
@@ -1116,12 +1226,11 @@ async function ensureLocalghostContext(options, vitePort, https) {
     ...typeof https === "boolean" ? { https } : {}
   });
   if (!hasReadySetup(cwd, context.entries, resolved.path, context.https)) {
-    if (options.setup === false || !canPrompt()) return context;
-    const setup = await confirm("Run caddy:setup now?", true);
-    if (setup) {
-      await setupProject(cwd, context.entries, resolved.path, context.https);
-      console.log(`All set. Setup state: ${getLocalghostStatePath(cwd)}`);
-    }
+    if (options.setup === false || !context.autoRepair) return context;
+    if (options.setup === "prompt" && (!canPrompt() || !await confirm("Repair Localghost setup now?", true))) return context;
+    console.log("Localghost setup is stale; repairing it now.");
+    await setupProject(cwd, context.entries, resolved.path, context.https);
+    console.log(`Repair complete. Setup state: ${getLocalghostStatePath(cwd)}`);
   }
   return context;
 }