@hamedb89/localghost 0.1.6 → 0.1.9

package/dist/vite.js

@@ -1,10 +1,125 @@
 // src/vite.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
 import { normalize, resolve as resolve2 } from "path";
+import { spawn } from "child_process";
+import { emitKeypressEvents } from "readline";
+
+// src/activity.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+var LOCALGHOST_ACTIVITY_VERSION = 1;
+function getLocalghostActivityPath(env = process.env) {
+  if (env.LOCALGHOST_ACTIVITY_PATH) return env.LOCALGHOST_ACTIVITY_PATH;
+  const stateRoot = env.XDG_STATE_HOME || join(homedir(), ".local/state");
+  return join(stateRoot, "localghost", "activity.json");
+}
+function isProcessRunning(pid) {
+  if (!Number.isInteger(pid) || pid < 1) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const code = typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
+    return code === "EPERM";
+  }
+}
+function emptyActivity() {
+  return { version: LOCALGHOST_ACTIVITY_VERSION, runs: [], setups: [] };
+}
+function readLocalghostActivity(path = getLocalghostActivityPath()) {
+  if (!existsSync(path)) return emptyActivity();
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    return {
+      version: LOCALGHOST_ACTIVITY_VERSION,
+      runs: Array.isArray(parsed.runs) ? parsed.runs : [],
+      setups: Array.isArray(parsed.setups) ? parsed.setups : []
+    };
+  } catch {
+    return emptyActivity();
+  }
+}
+function writeLocalghostActivity(activity, path = getLocalghostActivityPath()) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(activity, null, 2)}
+`, "utf8");
+  return path;
+}
+function createRunId(input2, pid) {
+  return `${input2.projectName}:${input2.mode}:${pid}:${Date.now()}`;
+}
+function createSetupId(input2) {
+  return `${input2.projectName}:${input2.cwd}:${input2.configPath ?? ""}`;
+}
+function pruneLocalghostActivity(path = getLocalghostActivityPath()) {
+  const activity = readLocalghostActivity(path);
+  const activeRuns = activity.runs.filter((run) => isProcessRunning(run.pid));
+  const pruned = activeRuns.length !== activity.runs.length;
+  if (pruned) {
+    writeLocalghostActivity({ ...activity, version: LOCALGHOST_ACTIVITY_VERSION, runs: activeRuns }, path);
+  }
+  return {
+    path,
+    pruned,
+    runs: activeRuns,
+    setups: activity.setups
+  };
+}
+function registerLocalghostRun(input2, path = getLocalghostActivityPath()) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const pid = input2.pid ?? process.pid;
+  const record = {
+    id: input2.id ?? createRunId(input2, pid),
+    mode: input2.mode,
+    pid,
+    cwd: input2.cwd,
+    projectName: input2.projectName,
+    startedAt: input2.startedAt ?? now,
+    updatedAt: now,
+    ...input2.configPath ? { configPath: input2.configPath } : {},
+    ...input2.caddyfilePath ? { caddyfilePath: input2.caddyfilePath } : {},
+    ...input2.caddyPid ? { caddyPid: input2.caddyPid } : {},
+    ...input2.childPid ? { childPid: input2.childPid } : {},
+    ...input2.childCommand ? { childCommand: input2.childCommand } : {},
+    ...typeof input2.https === "boolean" ? { https: input2.https } : {},
+    ...input2.requestedPort ? { requestedPort: input2.requestedPort } : {},
+    ...input2.port ? { port: input2.port } : {},
+    ...typeof input2.dynamicPort === "boolean" ? { dynamicPort: input2.dynamicPort } : {},
+    entries: input2.entries
+  };
+  const current = pruneLocalghostActivity(path).runs.filter((run) => run.id !== record.id);
+  const activity = readLocalghostActivity(path);
+  writeLocalghostActivity({ version: LOCALGHOST_ACTIVITY_VERSION, runs: [...current, record], setups: activity.setups }, path);
+  return record;
+}
+function registerLocalghostSetup(input2, path = getLocalghostActivityPath()) {
+  const record = {
+    id: input2.id ?? createSetupId(input2),
+    cwd: input2.cwd,
+    projectName: input2.projectName,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...input2.configPath ? { configPath: input2.configPath } : {},
+    ...input2.caddyfilePath ? { caddyfilePath: input2.caddyfilePath } : {},
+    ...typeof input2.https === "boolean" ? { https: input2.https } : {},
+    entries: input2.entries
+  };
+  const activity = pruneLocalghostActivity(path);
+  const setups = activity.setups.filter((setup) => setup.id !== record.id);
+  writeLocalghostActivity({ version: LOCALGHOST_ACTIVITY_VERSION, runs: activity.runs, setups: [...setups, record] }, path);
+  return record;
+}
+function unregisterLocalghostRun(id, path = getLocalghostActivityPath()) {
+  const activity = readLocalghostActivity(path);
+  const runs = activity.runs.filter((run) => run.id !== id);
+  if (runs.length !== activity.runs.length) {
+    writeLocalghostActivity({ ...activity, version: LOCALGHOST_ACTIVITY_VERSION, runs }, path);
+  }
+}
 
 // src/config.ts
-import { existsSync, readFileSync, readdirSync } from "fs";
-import { basename, join, resolve } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync } from "fs";
+import { basename, join as join2, resolve } from "path";
 
 // src/parse.ts
 var HOST_PATTERN = /^(?=.{1,253}$)(?!-)[a-z0-9-]+(\.[a-z0-9-]+)*\.?$/i;
@@ -69,7 +184,7 @@ function resolveDevHostsPath(options = {}) {
   const searchedFiles = getConfigFileCandidates(options);
   for (const fileName2 of searchedFiles) {
     const path = resolve(cwd, fileName2);
-    if (existsSync(path)) {
+    if (existsSync2(path)) {
       return {
         path,
         fileName: basename(fileName2),
@@ -102,11 +217,11 @@ function readDevHosts(options = {}) {
       `Missing Localghost config in ${cwd}. Looked for ${formatSearchedFiles(resolvedPath.searchedFiles, resolvedPath.configPattern)}. Run \`localghost init\` or pass --config/--config-pattern.`
     );
   }
-  return parseDevHosts(readFileSync(resolvedPath.path, "utf8"), resolvedPath.fileName);
+  return parseDevHosts(readFileSync2(resolvedPath.path, "utf8"), resolvedPath.fileName);
 }
 function getProjectName(cwd = process.cwd()) {
   try {
-    const pkg = JSON.parse(readFileSync(join(cwd, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync2(join2(cwd, "package.json"), "utf8"));
     const name = typeof pkg.name === "string" && pkg.name ? pkg.name : "app";
     return sanitizeProjectName(name.replace(/^@/, ""));
   } catch {
@@ -118,6 +233,11 @@ function sanitizeProjectName(value) {
   return projectName || "app";
 }
 
+// src/context.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join3 } from "path";
+import { pathToFileURL } from "url";
+
 // src/port.ts
 import { createServer } from "net";
 async function isPortAvailable(port, host = "127.0.0.1") {
@@ -144,7 +264,263 @@ async function findAvailablePort(startPort, options = {}) {
   throw new Error(`No available port found from ${startPort} to ${startPort + maxAttempts - 1}.`);
 }
 
+// src/tunnel.ts
+import { domainToASCII } from "url";
+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";
+function isResolvedGhostTunnelConfig(value) {
+  return typeof value === "object" && value !== null && "enabled" in value;
+}
+function toGhostTunnelConfig(options) {
+  return isResolvedGhostTunnelConfig(options) ? options : resolveGhostTunnelConfig(options);
+}
+function stripHostPort(value) {
+  const trimmed = value.trim().toLowerCase();
+  if (trimmed.startsWith("[") || trimmed.includes("/")) return "";
+  const portSeparator = trimmed.lastIndexOf(":");
+  if (portSeparator === -1) return trimmed;
+  const port = trimmed.slice(portSeparator + 1);
+  return /^\d+$/.test(port) ? trimmed.slice(0, portSeparator) : trimmed;
+}
+function normalizeDomain(value) {
+  const host = stripHostPort(value.replace(/^\*\./, ""));
+  const ascii = domainToASCII(host);
+  if (!ascii || ascii.length > 253 || ascii.includes("..")) return null;
+  if (ascii.startsWith(".") || ascii.endsWith(".")) return null;
+  if (ascii.includes("*")) return null;
+  if (!ascii.split(".").every(isValidHostLabel)) return null;
+  return ascii;
+}
+function isValidHostLabel(value) {
+  return value.length > 0 && value.length <= 63 && /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/.test(value);
+}
+function isValidNamespaceTag(value) {
+  return /^[a-z][a-z0-9_]*$/i.test(value);
+}
+function isNamespaceTagList(options) {
+  return Array.isArray(options);
+}
+function assertValidSubdomain(value) {
+  if (!isValidHostLabel(value)) {
+    throw new Error(`Invalid ghost tunnel subdomain: ${value}`);
+  }
+}
+function normalizeDomains(domains) {
+  const values = typeof domains === "string" ? [domains] : [...domains ?? []];
+  const normalized = values.map((value) => value.trim()).filter(Boolean).map((value) => {
+    const domain = normalizeDomain(value);
+    if (!domain) throw new Error(`Invalid ghost tunnel domain: ${value}`);
+    return domain;
+  });
+  return [...new Set(normalized)];
+}
+function parseGhostTunnelMode(value) {
+  return value ?? DEFAULT_GHOST_TUNNEL_MODE;
+}
+function resolveNamespaceConfig(options) {
+  const tags = isNamespaceTagList(options) ? [...options] : [...options?.tags ?? DEFAULT_GHOST_TUNNEL_NAMESPACE_TAGS];
+  let separator = DEFAULT_GHOST_TUNNEL_NAMESPACE_SEPARATOR;
+  let spreadTag = tags.includes("project") ? "project" : void 0;
+  if (options && !isNamespaceTagList(options)) {
+    separator = options.separator ?? DEFAULT_GHOST_TUNNEL_NAMESPACE_SEPARATOR;
+    spreadTag = options.spreadTag === false ? false : options.spreadTag ?? spreadTag;
+  }
+  if (tags.length === 0) {
+    throw new Error("Ghost tunnel namespace must include at least one tag.");
+  }
+  for (const tag of tags) {
+    if (!isValidNamespaceTag(tag)) {
+      throw new Error(`Invalid ghost tunnel namespace tag: ${tag}`);
+    }
+  }
+  if (spreadTag && !tags.includes(spreadTag)) {
+    throw new Error(`Ghost tunnel namespace spreadTag must be listed in tags: ${spreadTag}`);
+  }
+  if (!separator || separator.length > 8 || !/^[a-z0-9-]+$/.test(separator)) {
+    throw new Error(`Invalid ghost tunnel namespace separator: ${separator}`);
+  }
+  return {
+    tags,
+    separator,
+    ...spreadTag ? { spreadTag } : {}
+  };
+}
+function normalizeNamespaceValue(tag, value, separator, options = {}) {
+  const normalized = normalizeDomain(value);
+  if (!normalized || normalized.includes(".")) {
+    throw new Error(`Invalid ghost tunnel namespace value for ${tag}: ${value}`);
+  }
+  if (!options.allowSeparator && normalized.includes(separator)) {
+    throw new Error(`Ghost tunnel namespace value for ${tag} cannot include separator "${separator}": ${value}`);
+  }
+  return normalized;
+}
+function createNamespaceSlug(config, values) {
+  const parts = config.tags.map((tag) => {
+    const value = values[tag];
+    if (!value) {
+      throw new Error(`Missing ghost tunnel namespace value: ${tag}`);
+    }
+    return normalizeNamespaceValue(tag, value, config.separator, { allowSeparator: tag === config.spreadTag });
+  });
+  const slug = parts.join(config.separator);
+  if (!isValidHostLabel(slug)) {
+    throw new Error(`Ghost tunnel namespace is too long for a DNS label: ${slug}`);
+  }
+  return slug;
+}
+function createNamespaceDisplaySlug(config, values = {}) {
+  return config.tags.map((tag) => {
+    const value = values[tag];
+    if (!value) return `<${tag}>`;
+    try {
+      return normalizeNamespaceValue(tag, value, config.separator, { allowSeparator: tag === config.spreadTag });
+    } catch {
+      return `<${tag}>`;
+    }
+  }).join(config.separator);
+}
+function getPreviewDefaults(preview, defaults) {
+  return {
+    domain: preview?.domain ?? defaults?.domain,
+    route: preview?.route ?? defaults?.route,
+    project: preview?.project ?? defaults?.project,
+    owner: preview?.owner ?? defaults?.owner,
+    values: {
+      ...defaults?.values ?? {},
+      ...preview?.values ?? {}
+    },
+    path: preview?.path,
+    protocol: preview?.protocol
+  };
+}
+function getDisplayValues(input2) {
+  return {
+    ...input2.route ? { route: input2.route } : {},
+    ...input2.project ? { project: input2.project } : {},
+    ...input2.owner ? { owner: input2.owner } : {},
+    ...input2.values
+  };
+}
+function createDisplayUrl(config, defaults, domain) {
+  const input2 = getPreviewDefaults(config.preview, 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}.*`;
+  const url = `${protocol}://${slug}.${entryHost}/`;
+  if (!input2.path) return url;
+  return `${url}${input2.path.replace(/^\/+/, "")}`;
+}
+function createDisplayUrls(config, defaults) {
+  const domains = config.domains.length > 0 ? config.domains : defaults?.domain ? [defaults.domain] : [];
+  const urls = domains.length > 0 ? domains.map((domain) => createDisplayUrl(config, defaults, domain)) : [createDisplayUrl(config, defaults)];
+  return [...new Set(urls)];
+}
+function maybeConstructPreviewUrl(config, defaults) {
+  if (!config.preview) return void 0;
+  const input2 = getPreviewDefaults(config.preview, defaults);
+  if (!input2.domain || !input2.route || !input2.project || !input2.owner) return void 0;
+  return constructGhostTunnelUrl({
+    domain: input2.domain,
+    route: input2.route,
+    project: input2.project,
+    owner: input2.owner,
+    values: input2.values,
+    ...input2.path ? { path: input2.path } : {},
+    ...input2.protocol ? { protocol: input2.protocol } : {},
+    ghostTunnel: config
+  });
+}
+function resolveGhostTunnelConfig(options, defaults) {
+  if (options === false || typeof options === "undefined") {
+    return {
+      enabled: false,
+      mode: DEFAULT_GHOST_TUNNEL_MODE,
+      domains: [],
+      subdomain: DEFAULT_GHOST_TUNNEL_SUBDOMAIN,
+      namespace: resolveNamespaceConfig(void 0),
+      displayUrls: [],
+      requireHttps: true,
+      requireAuth: true
+    };
+  }
+  const config = typeof options === "string" ? { mode: options } : options;
+  const subdomain = config.subdomain ?? DEFAULT_GHOST_TUNNEL_SUBDOMAIN;
+  assertValidSubdomain(subdomain);
+  const domains = normalizeDomains(config.domains);
+  const enabled = config.enabled ?? true;
+  const resolved = {
+    enabled,
+    mode: parseGhostTunnelMode(config.mode),
+    domains,
+    subdomain,
+    namespace: resolveNamespaceConfig(config.namespace),
+    ...config.preview ? { preview: config.preview } : {},
+    displayUrls: [],
+    requireHttps: config.requireHttps ?? true,
+    requireAuth: config.requireAuth ?? true
+  };
+  if (!enabled) {
+    return resolved;
+  }
+  const previewUrl = maybeConstructPreviewUrl(resolved, defaults);
+  const displayUrls = previewUrl ? [previewUrl] : createDisplayUrls(resolved, defaults);
+  return {
+    ...resolved,
+    displayUrls,
+    ...displayUrls[0] ? { displayUrl: displayUrls[0] } : {},
+    ...previewUrl ? { previewUrl } : {}
+  };
+}
+function getGhostTunnelEntryHost(domain, options = {}) {
+  const config = toGhostTunnelConfig(options);
+  const normalizedDomain = normalizeDomain(domain);
+  if (!normalizedDomain) {
+    throw new Error(`Invalid ghost tunnel domain: ${domain}`);
+  }
+  return `${config.subdomain}.${normalizedDomain}`;
+}
+function constructGhostTunnelHost(input2) {
+  const config = toGhostTunnelConfig(input2.ghostTunnel ?? {});
+  if (!config.enabled) {
+    throw new Error("Ghost tunnel is not enabled.");
+  }
+  const namespaceValues = {
+    route: input2.route,
+    project: input2.project,
+    owner: input2.owner,
+    ...input2.values ?? {}
+  };
+  const slug = createNamespaceSlug(config.namespace, namespaceValues);
+  return `${slug}.${getGhostTunnelEntryHost(input2.domain, config)}`;
+}
+function constructGhostTunnelUrl(input2) {
+  const protocol = input2.protocol ?? "https";
+  const host = constructGhostTunnelHost(input2);
+  const url = new URL(`${protocol}://${host}/`);
+  if (input2.path) {
+    url.pathname = `/${input2.path.replace(/^\/+/, "")}`;
+  }
+  if (input2.searchParams instanceof URLSearchParams) {
+    url.search = input2.searchParams.toString();
+  } else if (input2.searchParams) {
+    for (const [key, value] of Object.entries(input2.searchParams)) {
+      if (typeof value !== "undefined" && value !== null) {
+        url.searchParams.set(key, String(value));
+      }
+    }
+  }
+  return url.toString();
+}
+
 // src/context.ts
+var LOCALGHOST_PROJECT_CONFIG_FILES = [
+  "localghost.config.mjs",
+  "localghost.config.js",
+  "localghost.config.cjs"
+];
 function parsePort(value) {
   if (!value) return void 0;
   const port = Number.parseInt(value, 10);
@@ -158,6 +534,30 @@ function envDynamicPort() {
   if (!value) return void 0;
   return ["1", "true", "yes", "on"].includes(value.toLowerCase());
 }
+function envHttps() {
+  const value = process.env.LOCALGHOST_HTTPS;
+  if (!value) return void 0;
+  return ["1", "true", "yes", "on"].includes(value.toLowerCase());
+}
+function getPackageName(cwd) {
+  try {
+    const pkg = JSON.parse(readFileSync3(join3(cwd, "package.json"), "utf8"));
+    return typeof pkg.name === "string" ? pkg.name : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function getPackageOwner(cwd) {
+  const packageName = getPackageName(cwd);
+  if (!packageName?.startsWith("@")) return void 0;
+  return packageName.slice(1).split("/")[0];
+}
+function getLocalOwner(cwd) {
+  return sanitizeProjectName(process.env.LOCALGHOST_OWNER ?? getPackageOwner(cwd) ?? process.env.USER ?? process.env.USERNAME ?? "local");
+}
+function getRouteName(primaryHost, fallback) {
+  return sanitizeProjectName(primaryHost.split(".")[0] ?? fallback);
+}
 function readOptionsFromContext(options) {
   return {
     cwd: options.cwd ?? process.cwd(),
@@ -175,22 +575,68 @@ function withRuntimePort(entries, requestedPort, port) {
 function uniqueHosts(entries) {
   return [...new Set(entries.map((entry) => entry.host))];
 }
+function isAliasableHost(host) {
+  return host.includes(".") && !host.startsWith("www.") && !host.includes(":");
+}
+function getDefaultWwwAlias(host) {
+  return isAliasableHost(host) ? `www.${host}` : null;
+}
+function addDefaultWwwAliases(entries) {
+  const seen = new Set(entries.map((entry) => entry.host));
+  const aliases = [];
+  for (const entry of entries) {
+    const alias = getDefaultWwwAlias(entry.host);
+    if (alias && !seen.has(alias)) {
+      aliases.push({ host: alias, port: entry.port, target: `127.0.0.1:${entry.port}` });
+      seen.add(alias);
+    }
+  }
+  return [...entries, ...aliases];
+}
+function defined(input2) {
+  return Object.fromEntries(Object.entries(input2).filter(([, value]) => typeof value !== "undefined"));
+}
+async function readLocalghostProjectConfig(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  if (options.configFile === false) return { config: {} };
+  const candidates = options.configFile ? [options.configFile] : LOCALGHOST_PROJECT_CONFIG_FILES;
+  const path = candidates.map((candidate) => resolveDevHostsPath({ cwd, fileName: candidate }).path).find((candidate) => existsSync3(candidate));
+  if (!path) return { config: {} };
+  const imported = await import(`${pathToFileURL(path).href}?localghost=${Date.now()}`);
+  const config = imported.default ?? imported;
+  return { config, path };
+}
 async function resolveLocalghostContext(options = {}) {
   const cwd = options.cwd ?? process.cwd();
-  const readOptions = readOptionsFromContext({ ...options, cwd });
+  const projectConfig = await readLocalghostProjectConfig({
+    cwd,
+    ...typeof options.localghostConfig !== "undefined" ? { configFile: options.localghostConfig } : {}
+  });
+  const merged = {
+    ...projectConfig.config,
+    ...defined(options)
+  };
+  const readOptions = readOptionsFromContext({ ...merged, cwd });
   const resolvedPath = resolveDevHostsPath(readOptions);
   const configEntries = readDevHosts(readOptions);
-  const requestedPort = options.port ?? envPort() ?? configEntries[0]?.port ?? 5173;
-  const dynamicPort = options.dynamicPort ?? envDynamicPort() ?? false;
-  const bindHost = options.bindHost ?? "127.0.0.1";
+  const requestedPort = merged.port ?? envPort() ?? configEntries[0]?.port ?? 5173;
+  const dynamicPort = merged.dynamicPort ?? envDynamicPort() ?? 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;
-  const entries = withRuntimePort(configEntries, requestedPort, port);
+  const wwwAlias = merged.wwwAlias ?? true;
+  const entries = wwwAlias ? addDefaultWwwAliases(withRuntimePort(configEntries, requestedPort, port)) : withRuntimePort(configEntries, requestedPort, port);
   const hosts = uniqueHosts(entries);
-  const primaryHost = options.primaryHost ?? entries.find((entry) => entry.port === port)?.host ?? hosts[0] ?? `${sanitizeProjectName(getProjectName(cwd))}.localhost`;
+  const primaryHost = merged.primaryHost ?? entries.find((entry) => entry.port === port)?.host ?? hosts[0] ?? `${sanitizeProjectName(getProjectName(cwd))}.localhost`;
+  const projectName = sanitizeProjectName(merged.project ?? getProjectName(cwd));
+  const ghostTunnel = resolveGhostTunnelConfig(merged.ghostTunnel, {
+    route: getRouteName(primaryHost, projectName),
+    project: projectName,
+    owner: getLocalOwner(cwd)
+  });
   return {
     cwd,
-    projectName: sanitizeProjectName(options.project ?? getProjectName(cwd)),
+    projectName,
     readOptions,
     configPath: resolvedPath.path,
     configFileName: resolvedPath.fileName,
@@ -202,7 +648,10 @@ async function resolveLocalghostContext(options = {}) {
     dynamicPort,
     bindHost,
     primaryHost,
-    https: options.https === true
+    https: merged.https ?? envHttps() ?? false,
+    wwwAlias,
+    ghostTunnel,
+    ...projectConfig.path ? { projectConfigPath: projectConfig.path } : {}
   };
 }
 
@@ -241,21 +690,21 @@ function isProductionLike(env = process.env) {
 }
 
 // src/fs.ts
-import { mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
-import { dirname } from "path";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2 } from "path";
 function readTextFile(path) {
-  return readFileSync2(path, "utf8");
+  return readFileSync4(path, "utf8");
 }
 function writeTextFile(path, value) {
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, value, "utf8");
+  mkdirSync2(dirname2(path), { recursive: true });
+  writeFileSync2(path, value, "utf8");
   return path;
 }
 
 // src/hosts-file.ts
-import { writeFileSync as writeFileSync2 } from "fs";
+import { writeFileSync as writeFileSync3 } from "fs";
 import { tmpdir } from "os";
-import { join as join2 } from "path";
+import { join as join4 } from "path";
 import { execa as execa2 } from "execa";
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -290,8 +739,8 @@ ${block}`;
 }
 async function writeSystemHostsFile(hostsPath, next, projectName) {
   const sanitizedProjectName = sanitizeProjectName(projectName);
-  const tempPath = join2(tmpdir(), `localghost-${sanitizedProjectName}-hosts`);
-  writeFileSync2(tempPath, next, "utf8");
+  const tempPath = join4(tmpdir(), `localghost-${sanitizedProjectName}-hosts`);
+  writeFileSync3(tempPath, next, "utf8");
   if (process.platform === "win32") {
     throw new Error(`Windows support: run as administrator and copy ${tempPath} to ${hostsPath}.`);
   }
@@ -342,26 +791,26 @@ async function ask(question, defaultValue) {
 }
 
 // src/state.ts
-import { existsSync as existsSync2 } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { join as join5 } from "path";
 var LOCALGHOST_STATE_FILE = "ops/local/localghost-state.json";
 function getLocalghostStatePath(cwd = process.cwd()) {
-  return join3(cwd, LOCALGHOST_STATE_FILE);
+  return join5(cwd, LOCALGHOST_STATE_FILE);
 }
 function readLocalghostState(cwd = process.cwd()) {
   const path = getLocalghostStatePath(cwd);
-  if (!existsSync2(path)) return null;
+  if (!existsSync4(path)) return null;
   return JSON.parse(readTextFile(path));
 }
 function writeLocalghostState(cwd, state) {
   const path = getLocalghostStatePath(cwd);
-  writeTextFile(path, `${JSON.stringify({ version: 1, updatedAt: (/* @__PURE__ */ new Date()).toISOString(), ...state }, null, 2)}
+  writeTextFile(path, `${JSON.stringify({ ...state, version: 1, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2)}
 `);
   return path;
 }
 
 // src/caddy.ts
-import { dirname as dirname2, join as join4 } from "path";
+import { dirname as dirname3, join as join6 } from "path";
 import { execa as execa3 } from "execa";
 function groupByPort(entries) {
   const groups = /* @__PURE__ */ new Map();
@@ -373,7 +822,7 @@ function groupByPort(entries) {
   return groups;
 }
 function getCaddyfilePath(cwd = process.cwd()) {
-  return join4(cwd, "ops/local/Caddyfile");
+  return join6(cwd, "ops/local/Caddyfile");
 }
 function renderCaddyfile(entries, options = {}) {
   const groups = groupByPort(entries);
@@ -399,11 +848,54 @@ async function writeCaddyfile(entries, cwd = process.cwd(), options = {}) {
 }
 async function validateCaddyfile(path) {
   await execa3("caddy", ["validate", "--config", path], {
-    cwd: dirname2(path),
+    cwd: dirname3(path),
     stdio: "inherit"
   });
 }
 
+// src/routes.ts
+var ansi = {
+  cyan: "\x1B[36m",
+  dim: "\x1B[2m",
+  green: "\x1B[32m",
+  reset: "\x1B[0m",
+  yellow: "\x1B[33m"
+};
+function colorize(value, color, enabled) {
+  return enabled ? `${color}${value}${ansi.reset}` : value;
+}
+function colorizeUrl(value, enabled) {
+  if (!enabled) return value;
+  return colorize(value.replace(/\*/g, `${ansi.yellow}*${ansi.cyan}`), ansi.cyan, enabled);
+}
+function formatGhostTunnel(config, options = {}) {
+  if (!config.enabled) return null;
+  const color = options.color === true;
+  const label = options.label ?? "expected";
+  const labelColor = label === "running" ? ansi.green : ansi.dim;
+  const lines = [
+    "localghost ghost tunnel",
+    `  mode: ${config.mode}`
+  ];
+  const urls = config.displayUrls.length > 0 ? config.displayUrls : config.displayUrl ? [config.displayUrl] : [];
+  if (urls.length === 0) {
+    lines.push(`  ${label}: unavailable`);
+  } else if (urls.length === 1) {
+    lines.push(`  ${colorize(label, labelColor, color)}: ${colorizeUrl(urls[0], color)}`);
+  } else {
+    lines.push(`  ${colorize(label, labelColor, color)}:`);
+    for (const url of urls) {
+      lines.push(`    ${colorizeUrl(url, color)}`);
+    }
+  }
+  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"}`);
+  }
+  return lines.join("\n");
+}
+
 // src/vite.ts
 function mergeAllowedHosts(current, hosts) {
   if (Array.isArray(current)) {
@@ -418,7 +910,11 @@ function getDisplayEntries(entries, vitePort) {
   const matchingEntries = entries.filter((entry) => entry.port === vitePort);
   return matchingEntries.length > 0 ? matchingEntries : entries;
 }
-function printLocalHosts(server, entries, vitePort, https) {
+function printLocalHosts(server, context) {
+  if (!context) return;
+  const entries = context.entries;
+  const vitePort = context.port;
+  const https = context.https;
   const displayEntries = getDisplayEntries(entries, vitePort);
   const protocol = https ? "https" : "http";
   const urls = displayEntries.map((entry) => `${protocol}://${entry.host}/`);
@@ -432,13 +928,24 @@ function printLocalHosts(server, entries, vitePort, https) {
     `  local:  ${primaryUrl}`,
     ...urls.slice(1).map((url) => `  also:   ${url}`),
     vitePort ? `  target: http://127.0.0.1:${vitePort}/` : void 0,
-    https ? "  proxy:  Caddy local HTTPS" : void 0
+    https ? "  proxy:  Caddy local HTTPS" : void 0,
+    context.ghostTunnel.enabled ? formatGhostTunnel(context.ghostTunnel, {
+      color: shouldColor(),
+      label: "ready",
+      verbose: optionsVerbose(context)
+    }) : void 0
   ].filter((line) => Boolean(line));
   server.config.logger.info(lines.join("\n"), {
     clear: false,
     timestamp: false
   });
 }
+function shouldColor() {
+  return process.stdout.isTTY && !process.env.NO_COLOR;
+}
+function optionsVerbose(context) {
+  return process.env.LOCALGHOST_VERBOSE === "1" || process.env.LOCALGHOST_VERBOSE === "true" || context.ghostTunnel.displayUrls.length > 1;
+}
 function readOptionsFromPlugin(options) {
   return {
     cwd: options.cwd ?? process.cwd(),
@@ -452,7 +959,8 @@ function getConfigWatchFiles(options) {
   const cwd = readOptions.cwd ?? process.cwd();
   const resolvedPath = resolveDevHostsPath(readOptions);
   const candidatePaths = getConfigFileCandidates(readOptions).map((fileName) => resolve2(cwd, fileName));
-  return [.../* @__PURE__ */ new Set([...candidatePaths, resolvedPath.path])];
+  const projectConfigPaths = options.localghostConfig === false ? [] : options.localghostConfig ? [resolve2(cwd, options.localghostConfig)] : ["localghost.config.mjs", "localghost.config.js", "localghost.config.cjs"].map((fileName) => resolve2(cwd, fileName));
+  return [.../* @__PURE__ */ new Set([...candidatePaths, resolvedPath.path, ...projectConfigPaths])];
 }
 function normalizeWatchPath(filePath) {
   return normalize(resolve2(filePath));
@@ -469,6 +977,57 @@ function defaultHost(cwd) {
   const projectName = sanitizeProjectName(getProjectName(cwd).split("/").pop() ?? "app");
   return `${projectName}.localhost`;
 }
+function getPackageOwner2(cwd) {
+  try {
+    const pkg = JSON.parse(readFileSync5(resolve2(cwd, "package.json"), "utf8"));
+    if (typeof pkg.name === "string" && pkg.name.startsWith("@")) {
+      return pkg.name.slice(1).split("/")[0];
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
+function getLocalOwner2(cwd) {
+  return sanitizeProjectName(process.env.LOCALGHOST_OWNER ?? getPackageOwner2(cwd) ?? process.env.USER ?? process.env.USERNAME ?? "local");
+}
+function getRouteName2(primaryHost, fallback) {
+  return sanitizeProjectName(primaryHost.split(".")[0] ?? fallback);
+}
+function readBuildEntries(options) {
+  const readOptions = readOptionsFromPlugin(options);
+  const resolved = resolveDevHostsPath(readOptions);
+  if (!resolved.exists) return [];
+  try {
+    return readDevHosts(readOptions);
+  } catch {
+    return [];
+  }
+}
+async function maybePrintBuildGhostTunnel(options) {
+  const cwd = options.cwd ?? process.cwd();
+  const projectConfig = await readLocalghostProjectConfig({
+    cwd,
+    ...typeof options.localghostConfig !== "undefined" ? { configFile: options.localghostConfig } : {}
+  });
+  const explicitGhostTunnel = typeof options.ghostTunnel !== "undefined" ? options.ghostTunnel : projectConfig.config.ghostTunnel;
+  if (!explicitGhostTunnel) return;
+  const entries = readBuildEntries(options);
+  const projectName = sanitizeProjectName(projectConfig.config.project ?? getProjectName(cwd));
+  const primaryHost = options.primaryHost ?? entries[0]?.host ?? defaultHost(cwd);
+  const ghostTunnel = resolveGhostTunnelConfig(explicitGhostTunnel, {
+    route: getRouteName2(primaryHost, projectName),
+    project: sanitizeProjectName(projectConfig.config.project ?? getProjectName(cwd)),
+    owner: getLocalOwner2(cwd)
+  });
+  if (!ghostTunnel.enabled) return;
+  const formatted = formatGhostTunnel(ghostTunnel, {
+    color: shouldColor(),
+    label: "configured",
+    verbose: options.verbose === true || process.env.LOCALGHOST_VERBOSE === "1" || process.env.LOCALGHOST_VERBOSE === "true"
+  });
+  if (formatted) console.log(formatted);
+}
 async function promptForHosts(cwd, port) {
   const primaryHost = await ask("Primary local domain", defaultHost(cwd));
   const hosts = [primaryHost.toLowerCase()];
@@ -476,20 +1035,20 @@ async function promptForHosts(cwd, port) {
     const host = await ask("Domain");
     if (host) hosts.push(host.toLowerCase());
   }
-  return [...new Set(hosts)];
+  return [...new Set(addDefaultWwwAliases(hosts.map((host) => ({ host, port, target: `127.0.0.1:${port}` }))).map((entry) => entry.host))];
 }
 function hasReadySetup(cwd, entries, configPath, https) {
   const state = readLocalghostState(cwd);
   const projectName = sanitizeProjectName(getProjectName(cwd));
   if (state?.action !== "setup" || state.configPath !== configPath) return false;
   try {
-    const hosts = readFileSync3(getSystemHostsPath(), "utf8");
+    const hosts = readFileSync5(getSystemHostsPath(), "utf8");
     if (!hosts.includes(renderHostsBlock(projectName, entries).trimEnd())) return false;
   } catch {
     return false;
   }
   const caddyfilePath = getCaddyfilePath(cwd);
-  return existsSync3(caddyfilePath) && readFileSync3(caddyfilePath, "utf8") === renderCaddyfile(entries, { https });
+  return existsSync5(caddyfilePath) && readFileSync5(caddyfilePath, "utf8") === renderCaddyfile(entries, { https });
 }
 async function setupProject(cwd, entries, configPath, https) {
   const caddy = await checkCaddy();
@@ -518,6 +1077,14 @@ async function setupProject(cwd, entries, configPath, https) {
     caddyHttps: https,
     entries
   });
+  registerLocalghostSetup({
+    cwd,
+    projectName,
+    configPath,
+    caddyfilePath,
+    https,
+    entries
+  });
 }
 async function ensureLocalghostContext(options, vitePort, https) {
   const cwd = options.cwd ?? process.cwd();
@@ -541,38 +1108,116 @@ async function ensureLocalghostContext(options, vitePort, https) {
     ...options,
     cwd,
     port: vitePort,
-    https
+    ...typeof https === "boolean" ? { https } : {}
   });
-  if (!hasReadySetup(cwd, context.entries, resolved.path, 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, https);
+      await setupProject(cwd, context.entries, resolved.path, context.https);
       console.log(`All set. Setup state: ${getLocalghostStatePath(cwd)}`);
     }
   }
   return context;
 }
+function isConcreteGhostUrl(url) {
+  return !url.includes("*") && !url.includes("<") && /^https?:\/\//.test(url);
+}
+function getConcreteGhostUrls(context) {
+  return context.ghostTunnel.displayUrls.filter(isConcreteGhostUrl);
+}
+function openExternalUrl(url) {
+  const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+  const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+  const child = spawn(command, args, {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+}
+function installGhostTunnelMenu(server, context) {
+  if (!context?.ghostTunnel.enabled || !process.stdin.isTTY) return void 0;
+  emitKeypressEvents(process.stdin);
+  let active = false;
+  const concreteUrls = getConcreteGhostUrls(context);
+  const printMenu = () => {
+    active = true;
+    const lines = [
+      "",
+      formatGhostTunnel(context.ghostTunnel, {
+        color: shouldColor(),
+        label: "ready",
+        verbose: true
+      }) ?? "localghost ghost tunnel",
+      ""
+    ];
+    if (concreteUrls.length === 0) {
+      lines.push("  No concrete Ghost Tunnel domain configured.");
+      lines.push("  Add ghostTunnel.domains to localghost.config.mjs to open a URL from this menu.");
+      active = false;
+    } else {
+      concreteUrls.forEach((url, index) => {
+        lines.push(`  ${index + 1}. ${url}`);
+      });
+      lines.push("");
+      lines.push("  Press a number to open, or escape to cancel.");
+    }
+    server.config.logger.info(lines.join("\n"), {
+      clear: false,
+      timestamp: false
+    });
+  };
+  const onKeypress = (_input, key = {}) => {
+    if (key.ctrl && key.name === "c") return;
+    if (!active) {
+      if (key.name === "g") printMenu();
+      return;
+    }
+    if (key.name === "escape") {
+      active = false;
+      return;
+    }
+    const index = Number.parseInt(key.name ?? "", 10) - 1;
+    const url = concreteUrls[index];
+    if (!url) return;
+    active = false;
+    openExternalUrl(url);
+    server.config.logger.info(`localghost opened ${url}`, {
+      clear: false,
+      timestamp: false
+    });
+  };
+  process.stdin.on("keypress", onKeypress);
+  return () => {
+    process.stdin.off("keypress", onKeypress);
+  };
+}
 function localGhostPlugin(options = {}) {
   let resolvedEntries = [];
   let resolvedVitePort;
+  let resolvedHttps = false;
+  let resolvedContext;
   let restartTimer;
+  let activityRunId;
   return {
     name: "localghost:vite",
     enforce: "pre",
     async config(userConfig, configEnv) {
       if (configEnv.command !== "serve" || configEnv.mode === "production" || isProductionLike()) {
+        await maybePrintBuildGhostTunnel(options);
         return {};
       }
       const existingServer = userConfig.server ?? {};
       const envVitePort = Number.parseInt(process.env.LOCALGHOST_PORT ?? process.env.VITE_PORT ?? "", 10);
       const requestedVitePort = options.port ?? existingServer.port ?? (Number.isInteger(envVitePort) ? envVitePort : 5173);
-      const context = await ensureLocalghostContext(options, requestedVitePort, Boolean(options.https));
+      const context = await ensureLocalghostContext(options, requestedVitePort, options.https);
       const entries = context.entries;
       const hosts = context.hosts;
       const primaryHost = context.primaryHost;
       resolvedEntries = entries;
       resolvedVitePort = context.port;
+      resolvedHttps = context.https;
+      resolvedContext = context;
       const server = {
         ...existingServer,
         allowedHosts: mergeAllowedHosts(existingServer.allowedHosts, hosts),
@@ -584,7 +1229,7 @@ function localGhostPlugin(options = {}) {
       if (context.port) {
         server.port = context.port;
       }
-      if (options.https && primaryHost) {
+      if (context.https && primaryHost) {
         const existingWs = typeof server.ws === "object" && server.ws ? server.ws : {};
         const existingHmr = typeof existingServer.hmr === "object" && existingServer.hmr ? existingServer.hmr : {};
         server.ws = {
@@ -632,9 +1277,38 @@ function localGhostPlugin(options = {}) {
       server.watcher.on("unlink", restartOnLocalghostConfigChange);
       if (options.log !== false) {
         server.printUrls = () => {
-          printLocalHosts(server, resolvedEntries, resolvedVitePort, Boolean(options.https));
+          printLocalHosts(server, resolvedContext);
         };
       }
+      if (resolvedContext) {
+        const run = registerLocalghostRun({
+          id: `${resolvedContext.projectName}:vite:${process.pid}:${resolvedContext.cwd}`,
+          mode: "vite",
+          pid: process.pid,
+          cwd: resolvedContext.cwd,
+          projectName: resolvedContext.projectName,
+          configPath: resolvedContext.configPath,
+          childCommand: ["vite"],
+          https: resolvedContext.https,
+          requestedPort: resolvedContext.requestedPort,
+          port: resolvedContext.port,
+          dynamicPort: resolvedContext.dynamicPort,
+          entries: resolvedContext.entries
+        });
+        activityRunId = run.id;
+      }
+      const cleanupGhostMenu = installGhostTunnelMenu(server, resolvedContext);
+      const cleanupActivity = () => {
+        if (!activityRunId) return;
+        unregisterLocalghostRun(activityRunId);
+        activityRunId = void 0;
+      };
+      const cleanup = () => {
+        cleanupActivity();
+        cleanupGhostMenu?.();
+      };
+      server.httpServer?.once("close", cleanup);
+      process.once("exit", cleanup);
     }
   };
 }