@hamedb89/localghost 0.5.0 → 0.6.2

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { existsSync as existsSync8, readFileSync as readFileSync8, unlinkSync } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync9, unlinkSync } from "fs";
 import { Command, InvalidArgumentError } from "commander";
 
 // src/activity.ts
@@ -480,20 +480,20 @@ function formatDetectedDevServices(services) {
 }
 
 // src/context.ts
-import { existsSync as existsSync4, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync6 } from "fs";
 import { join as join6 } from "path";
 import { pathToFileURL } from "url";
 
 // src/port.ts
 import { createServer } from "net";
 async function isPortAvailable(port, host = "127.0.0.1") {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const server = createServer();
     server.once("error", () => {
-      resolve5(false);
+      resolve6(false);
     });
     server.once("listening", () => {
-      server.close(() => resolve5(true));
+      server.close(() => resolve6(true));
     });
     server.listen(port, host);
   });
@@ -546,6 +546,9 @@ function validRegistry(value) {
 function pruneRegistry(registry, now, isRunning) {
   registry.leases = registry.leases.filter((lease) => lease.expiresAt > now && isRunning(lease.pid));
 }
+function isTestSessionKey(instanceKey) {
+  return instanceKey.startsWith("test:");
+}
 async function readJson(path) {
   try {
     return JSON.parse(await readFile(path, "utf8"));
@@ -642,6 +645,37 @@ function createLocalghostRegistry(options = {}) {
         await releaseLock();
       }
     },
+    async pruneTestSessions() {
+      const releaseLock = await lock();
+      try {
+        const registry = await readRegistry();
+        const staleTestKeys = new Set(
+          registry.leases.filter((lease) => isTestSessionKey(lease.instanceKey) && (lease.expiresAt <= now() || !isRunning(lease.pid))).map((lease) => leaseKey(lease.projectCwd, lease.instanceKey))
+        );
+        const beforeLeases = registry.leases.length;
+        registry.leases = registry.leases.filter((lease) => !staleTestKeys.has(leaseKey(lease.projectCwd, lease.instanceKey)));
+        const activeKeys = new Set(registry.leases.map((lease) => leaseKey(lease.projectCwd, lease.instanceKey)));
+        const beforeAllocations = registry.allocations.length;
+        registry.allocations = registry.allocations.filter(
+          (allocation) => !isTestSessionKey(allocation.instanceKey) || activeKeys.has(leaseKey(allocation.projectCwd, allocation.instanceKey))
+        );
+        await writeRegistry(registry);
+        return {
+          removedLeases: beforeLeases - registry.leases.length,
+          removedAllocations: beforeAllocations - registry.allocations.length
+        };
+      } finally {
+        await releaseLock();
+      }
+    },
+    async reset() {
+      const releaseLock = await lock();
+      try {
+        await writeRegistry({ version: 1, allocations: [], leases: [] });
+      } finally {
+        await releaseLock();
+      }
+    },
     async acquirePort(acquireOptions) {
       const projectCwd = canonicalizeLocalghostProjectCwd(acquireOptions.projectCwd ?? cwd);
       if (!acquireOptions.instanceKey) throw new Error("instanceKey is required");
@@ -704,7 +738,7 @@ function createLocalghostRegistry(options = {}) {
   };
 }
 
-// src/tunnel.ts
+// packages/ghost-tunnel/src/tunnel.ts
 import { domainToASCII } from "url";
 var DEFAULT_GHOST_TUNNEL_SUBDOMAIN = "ghost";
 var DEFAULT_GHOST_TUNNEL_NAMESPACE_TAGS = ["route", "project", "owner"];
@@ -1055,275 +1089,7 @@ function constructGhostTunnelUrl(input2) {
   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);
-  return Number.isInteger(port) && port > 0 && port <= 65535 ? port : void 0;
-}
-function envPort() {
-  return parsePort(process.env.LOCALGHOST_PORT) ?? parsePort(process.env.VITE_PORT);
-}
-function envDynamicPort() {
-  const value = process.env.LOCALGHOST_DYNAMIC_PORT;
-  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(readFileSync5(join6(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(),
-    ...options.fileName ? { fileName: options.fileName } : {},
-    ...options.configFiles ? { configFiles: options.configFiles } : {},
-    ...options.configPattern ? { configPattern: options.configPattern } : {}
-  };
-}
-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, target: `127.0.0.1:${port}` } : entry);
-}
-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) => existsSync4(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 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 = 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";
-  let port = requestedPort;
-  let releasePort;
-  const reservePort = merged.reservePort ?? false;
-  const instanceKey = merged.instanceKey ?? "run";
-  if (reservePort && dynamicPort) {
-    const registry = createLocalghostRegistry({ cwd, ...merged.registryOwnerToken ? { ownerToken: merged.registryOwnerToken } : {} });
-    const lease = await registry.acquirePort({
-      projectCwd: cwd,
-      instanceKey,
-      startPort: requestedPort,
-      host: probeHost,
-      ...options.reservedPorts ? { reservedPorts: options.reservedPorts } : {}
-    });
-    port = lease.port;
-    releasePort = () => registry.releasePort({ projectCwd: cwd, instanceKey });
-  } else if (dynamicPort) {
-    port = await findAvailablePort(requestedPort, { host: probeHost });
-  }
-  const wwwAlias = merged.wwwAlias ?? true;
-  const entries = wwwAlias ? addDefaultWwwAliases(withRuntimePort(configEntries, requestedPort, port)) : withRuntimePort(configEntries, requestedPort, port);
-  const hosts = uniqueHosts(entries);
-  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,
-    readOptions,
-    configPath: resolvedPath.path,
-    configFileName: resolvedPath.fileName,
-    configEntries,
-    entries,
-    hosts,
-    requestedPort,
-    port,
-    dynamicPort,
-    autoRepair,
-    bindHost,
-    primaryHost,
-    https: merged.https ?? envHttps() ?? false,
-    wwwAlias,
-    ghostTunnel,
-    ...projectConfig.path ? { projectConfigPath: projectConfig.path } : {},
-    ...releasePort ? { releasePort } : {}
-  };
-}
-
-// src/doctor.ts
-import { execa as execa2 } from "execa";
-async function checkCaddy() {
-  try {
-    const result = await execa2("caddy", ["version"], { reject: false });
-    const version = [result.stdout, result.stderr].filter(Boolean).join("\n").trim();
-    return {
-      found: result.exitCode === 0,
-      ...version ? { version } : {},
-      installHint: "brew install caddy"
-    };
-  } catch {
-    return {
-      found: false,
-      installHint: "brew install caddy"
-    };
-  }
-}
-async function runDoctor(options = {}) {
-  const caddy = await checkCaddy();
-  const cwd = options.cwd ?? process.cwd();
-  const registry = createLocalghostRegistry({ cwd });
-  const data = await registry.read();
-  const now = Date.now();
-  const staleLeases = data.leases.filter((lease) => lease.expiresAt <= now || !isProcessRunning(lease.pid)).map(({ projectCwd, instanceKey, port, pid }) => ({ projectCwd, instanceKey, port, pid }));
-  const allocationsByPort = /* @__PURE__ */ new Map();
-  for (const allocation of data.allocations) {
-    const projects = allocationsByPort.get(allocation.port) ?? [];
-    projects.push(`${allocation.projectCwd}#${allocation.instanceKey}`);
-    allocationsByPort.set(allocation.port, projects);
-  }
-  const duplicateAllocations = [...allocationsByPort.entries()].filter(([, projects]) => projects.length > 1).map(([port, projects]) => ({ port, projects }));
-  let configured;
-  let available;
-  try {
-    const context = await resolveLocalghostContext({
-      cwd,
-      ...options.configFiles ? { configFiles: options.configFiles } : {},
-      ...options.configPattern ? { configPattern: options.configPattern } : {},
-      dynamicPort: false
-    });
-    configured = context.requestedPort;
-    available = await isPortAvailable(configured);
-  } catch {
-  }
-  const currentProjectCwd = canonicalizeLocalghostProjectCwd(cwd);
-  const currentAllocation = data.allocations.find((allocation) => allocation.projectCwd === currentProjectCwd);
-  return {
-    ok: caddy.found && available !== false && staleLeases.length === 0 && duplicateAllocations.length === 0,
-    caddy,
-    ports: {
-      ...configured !== void 0 ? { configured } : {},
-      ...available !== void 0 ? { available } : {},
-      registryPath: registry.registryPath,
-      staleLeases,
-      duplicateAllocations,
-      ...currentAllocation ? {
-        currentAllocation: {
-          projectCwd: currentAllocation.projectCwd,
-          instanceKey: currentAllocation.instanceKey,
-          port: currentAllocation.port
-        }
-      } : {}
-    }
-  };
-}
-
-// src/env.ts
-function getProductionReason(env = process.env) {
-  if (env.LOCALGHOST_ENV === "production") return "LOCALGHOST_ENV=production";
-  if (env.NODE_ENV === "production") return "NODE_ENV=production";
-  if (env.VERCEL_ENV === "production") return "VERCEL_ENV=production";
-  if (env.NETLIFY === "true" && env.CONTEXT === "production") return "NETLIFY=true and CONTEXT=production";
-  if (env.CF_PAGES_BRANCH && env.CF_PAGES_BRANCH === env.CF_PAGES_PRODUCTION_BRANCH) {
-    return "CF_PAGES_BRANCH matches CF_PAGES_PRODUCTION_BRANCH";
-  }
-  return null;
-}
-function assertLocalDevelopment(command, env = process.env) {
-  const reason = getProductionReason(env);
-  if (!reason) return;
-  throw new Error(`Localghost only runs in local development. Refusing \`${command}\` because ${reason}.`);
-}
-
-// src/ghost-file.ts
-var LOCALGHOST_GHOST_TUNNEL_FILE = ".ghosttunnel";
-function toGhostTunnelOptions(options = {}) {
-  const resolved = typeof options === "string" ? { cwd: options } : options;
-  return {
-    ...resolved,
-    fileName: resolved.fileName ?? LOCALGHOST_GHOST_TUNNEL_FILE
-  };
-}
-function resolveGhostTunnelPath(options = {}) {
-  return resolveDevHostsPath(toGhostTunnelOptions(options));
-}
-function readGhostTunnelEntries(options = {}) {
-  return readDevHosts(toGhostTunnelOptions(options));
-}
-function listGhostTunnelEntries(options = {}) {
-  const resolved = resolveGhostTunnelPath(options);
-  if (!resolved.exists) return [];
-  return readGhostTunnelEntries(options);
-}
-
-// src/ghost-agent.ts
-import { randomUUID as randomUUID3 } from "crypto";
-
-// src/relay.ts
+// packages/ghost-tunnel/src/relay.ts
 import { createHmac, timingSafeEqual } from "crypto";
 import { domainToASCII as domainToASCII2 } from "url";
 var DEFAULT_RELAY_ALLOWED_TARGET_HOSTS = ["localhost", "127.0.0.1", "::1"];
@@ -1432,7 +1198,73 @@ function stripRelayForwardHeaders(headers) {
   return stripped;
 }
 
-// src/ghost-tunnel-store.ts
+// packages/ghost-tunnel/src/ghost-file.ts
+import { existsSync as existsSync4, readFileSync as readFileSync5, readdirSync as readdirSync2 } from "fs";
+import { basename as basename2, resolve as resolve4 } from "path";
+var LOCALGHOST_GHOST_TUNNEL_FILE = ".ghosttunnel";
+function getCandidates(options) {
+  const exact = [.../* @__PURE__ */ new Set([...options.fileName ? [options.fileName] : [], ...options.configFiles ?? []])];
+  const pattern = options.configPattern ? readdirSync2(options.cwd ?? process.cwd(), { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name).filter((name) => {
+    const matcher = typeof options.configPattern === "string" ? new RegExp(options.configPattern) : options.configPattern;
+    if (!matcher) return false;
+    matcher.lastIndex = 0;
+    return matcher.test(name);
+  }).sort() : [];
+  if (exact.length > 0 || pattern.length > 0) return [.../* @__PURE__ */ new Set([...exact, ...pattern])];
+  return [LOCALGHOST_GHOST_TUNNEL_FILE];
+}
+function parseGhostTunnelEntries(input2, fileName) {
+  const entries = [];
+  input2.split(/\r?\n/).forEach((rawLine, index) => {
+    const line = rawLine.replace(/#.*/, "").trim();
+    if (!line) return;
+    const parts = line.split(/\s+/);
+    const host = parts[0];
+    const portRaw = parts[1];
+    if (!host || !portRaw || parts.length > 2) {
+      throw new Error(`Invalid ${fileName} line ${index + 1}: "${rawLine}"`);
+    }
+    if (!/^(?=.{1,253}$)(?!-)[a-z0-9-]+(\.[a-z0-9-]+)*\.?$/i.test(host)) {
+      throw new Error(`Invalid host on line ${index + 1}: "${host}"`);
+    }
+    const port = Number(portRaw);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+      throw new Error(`Invalid port on line ${index + 1}: "${portRaw}"`);
+    }
+    entries.push({ host: host.toLowerCase().replace(/\.$/, ""), port, target: `127.0.0.1:${port}` });
+  });
+  return entries;
+}
+function toGhostTunnelOptions(options = {}) {
+  const resolved = typeof options === "string" ? { cwd: options } : options;
+  return {
+    ...resolved,
+    fileName: resolved.fileName ?? LOCALGHOST_GHOST_TUNNEL_FILE
+  };
+}
+function resolveGhostTunnelPath(options = {}) {
+  const resolved = toGhostTunnelOptions(options);
+  const cwd = resolved.cwd ?? process.cwd();
+  const searchedFiles = getCandidates(resolved);
+  for (const fileName2 of searchedFiles) {
+    const path = resolve4(cwd, fileName2);
+    if (existsSync4(path)) return { path, fileName: basename2(fileName2), exists: true, searchedFiles };
+  }
+  const fileName = searchedFiles[0] ?? LOCALGHOST_GHOST_TUNNEL_FILE;
+  return { path: resolve4(cwd, fileName), fileName: basename2(fileName), exists: false, searchedFiles };
+}
+function readGhostTunnelEntries(options = {}) {
+  const resolved = resolveGhostTunnelPath(options);
+  if (!resolved.exists) throw new Error(`Missing Ghost Tunnel file: ${resolved.path}`);
+  return parseGhostTunnelEntries(readFileSync5(resolved.path, "utf8"), resolved.fileName);
+}
+function listGhostTunnelEntries(options = {}) {
+  const resolved = resolveGhostTunnelPath(options);
+  if (!resolved.exists) return [];
+  return readGhostTunnelEntries(options);
+}
+
+// packages/ghost-tunnel/src/ghost-tunnel-store.ts
 import { randomUUID as randomUUID2 } from "crypto";
 function base64Encode(value) {
   return value.toString("base64");
@@ -1564,17 +1396,18 @@ function createRedisGhostTunnelStoreFromEnv(input2 = {}) {
   });
 }
 
-// src/ghost-agent.ts
+// packages/ghost-tunnel/src/ghost-agent.ts
+import { randomUUID as randomUUID3 } from "crypto";
 function isStopped(signal, localSignal) {
   return localSignal.aborted || signal?.aborted === true;
 }
 function wait(ms, signal, localSignal) {
   if (isStopped(signal, localSignal)) return Promise.resolve();
-  return new Promise((resolve5) => {
-    const timeout = setTimeout(resolve5, ms);
+  return new Promise((resolve6) => {
+    const timeout = setTimeout(resolve6, ms);
     const stop = () => {
       clearTimeout(timeout);
-      resolve5();
+      resolve6();
     };
     signal?.addEventListener("abort", stop, { once: true });
     localSignal.addEventListener("abort", stop, { once: true });
@@ -1712,6 +1545,250 @@ function startGhostTunnelAgent(options) {
   };
 }
 
+// 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);
+  return Number.isInteger(port) && port > 0 && port <= 65535 ? port : void 0;
+}
+function envPort() {
+  return parsePort(process.env.LOCALGHOST_PORT) ?? parsePort(process.env.VITE_PORT);
+}
+function envDynamicPort() {
+  const value = process.env.LOCALGHOST_DYNAMIC_PORT;
+  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(readFileSync6(join6(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(),
+    ...options.fileName ? { fileName: options.fileName } : {},
+    ...options.configFiles ? { configFiles: options.configFiles } : {},
+    ...options.configPattern ? { configPattern: options.configPattern } : {}
+  };
+}
+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, target: `127.0.0.1:${port}` } : entry);
+}
+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) => existsSync5(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 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 = 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";
+  let port = requestedPort;
+  let releasePort;
+  const reservePort = merged.reservePort ?? false;
+  const instanceKey = merged.instanceKey ?? "run";
+  if (reservePort && dynamicPort) {
+    const registry = createLocalghostRegistry({ cwd, ...merged.registryOwnerToken ? { ownerToken: merged.registryOwnerToken } : {} });
+    const lease = await registry.acquirePort({
+      projectCwd: cwd,
+      instanceKey,
+      startPort: requestedPort,
+      host: probeHost,
+      ...options.reservedPorts ? { reservedPorts: options.reservedPorts } : {}
+    });
+    port = lease.port;
+    releasePort = () => registry.releasePort({ projectCwd: cwd, instanceKey });
+  } else if (dynamicPort) {
+    port = await findAvailablePort(requestedPort, { host: probeHost });
+  }
+  const wwwAlias = merged.wwwAlias ?? true;
+  const entries = wwwAlias ? addDefaultWwwAliases(withRuntimePort(configEntries, requestedPort, port)) : withRuntimePort(configEntries, requestedPort, port);
+  const hosts = uniqueHosts(entries);
+  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,
+    readOptions,
+    configPath: resolvedPath.path,
+    configFileName: resolvedPath.fileName,
+    configEntries,
+    entries,
+    hosts,
+    requestedPort,
+    port,
+    dynamicPort,
+    autoRepair,
+    bindHost,
+    primaryHost,
+    https: merged.https ?? envHttps() ?? false,
+    wwwAlias,
+    ghostTunnel,
+    ...projectConfig.path ? { projectConfigPath: projectConfig.path } : {},
+    ...releasePort ? { releasePort } : {}
+  };
+}
+
+// src/doctor.ts
+import { execa as execa2 } from "execa";
+async function checkCaddy() {
+  try {
+    const result = await execa2("caddy", ["version"], { reject: false });
+    const version = [result.stdout, result.stderr].filter(Boolean).join("\n").trim();
+    return {
+      found: result.exitCode === 0,
+      ...version ? { version } : {},
+      installHint: "brew install caddy"
+    };
+  } catch {
+    return {
+      found: false,
+      installHint: "brew install caddy"
+    };
+  }
+}
+async function runDoctor(options = {}) {
+  const caddy = await checkCaddy();
+  const cwd = options.cwd ?? process.cwd();
+  const registry = createLocalghostRegistry({ cwd });
+  const data = await registry.read();
+  const now = Date.now();
+  const staleLeases = data.leases.filter((lease) => lease.expiresAt <= now || !isProcessRunning(lease.pid)).map(({ projectCwd, instanceKey, port, pid }) => ({ projectCwd, instanceKey, port, pid }));
+  const allocationsByPort = /* @__PURE__ */ new Map();
+  for (const allocation of data.allocations) {
+    const projects = allocationsByPort.get(allocation.port) ?? [];
+    projects.push(`${allocation.projectCwd}#${allocation.instanceKey}`);
+    allocationsByPort.set(allocation.port, projects);
+  }
+  const duplicateAllocations = [...allocationsByPort.entries()].filter(([, projects]) => projects.length > 1).map(([port, projects]) => ({ port, projects }));
+  let configured;
+  let available;
+  try {
+    const context = await resolveLocalghostContext({
+      cwd,
+      ...options.configFiles ? { configFiles: options.configFiles } : {},
+      ...options.configPattern ? { configPattern: options.configPattern } : {},
+      dynamicPort: false
+    });
+    configured = context.requestedPort;
+    available = await isPortAvailable(configured);
+  } catch {
+  }
+  const currentProjectCwd = canonicalizeLocalghostProjectCwd(cwd);
+  const currentAllocation = data.allocations.find((allocation) => allocation.projectCwd === currentProjectCwd);
+  return {
+    ok: caddy.found && available !== false && staleLeases.length === 0 && duplicateAllocations.length === 0,
+    caddy,
+    ports: {
+      ...configured !== void 0 ? { configured } : {},
+      ...available !== void 0 ? { available } : {},
+      registryPath: registry.registryPath,
+      staleLeases,
+      duplicateAllocations,
+      ...currentAllocation ? {
+        currentAllocation: {
+          projectCwd: currentAllocation.projectCwd,
+          instanceKey: currentAllocation.instanceKey,
+          port: currentAllocation.port
+        }
+      } : {}
+    }
+  };
+}
+
+// src/env.ts
+function getProductionReason(env = process.env) {
+  if (env.LOCALGHOST_ENV === "production") return "LOCALGHOST_ENV=production";
+  if (env.NODE_ENV === "production") return "NODE_ENV=production";
+  if (env.VERCEL_ENV === "production") return "VERCEL_ENV=production";
+  if (env.NETLIFY === "true" && env.CONTEXT === "production") return "NETLIFY=true and CONTEXT=production";
+  if (env.CF_PAGES_BRANCH && env.CF_PAGES_BRANCH === env.CF_PAGES_PRODUCTION_BRANCH) {
+    return "CF_PAGES_BRANCH matches CF_PAGES_PRODUCTION_BRANCH";
+  }
+  return null;
+}
+function assertLocalDevelopment(command, env = process.env) {
+  const reason = getProductionReason(env);
+  if (!reason) return;
+  throw new Error(`Localghost only runs in local development. Refusing \`${command}\` because ${reason}.`);
+}
+
 // src/hosts-file.ts
 import { writeFileSync as writeFileSync3 } from "fs";
 import { tmpdir } from "os";
@@ -1795,19 +1872,19 @@ async function removeSystemHosts(projectName) {
 }
 
 // src/init.ts
-import { existsSync as existsSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
-import { dirname as dirname4, join as join8, resolve as resolve4 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname4, join as join8, resolve as resolve5 } from "path";
 function detectPackageManager(cwd = process.cwd()) {
-  if (existsSync5(join8(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (existsSync5(join8(cwd, "yarn.lock"))) return "yarn";
-  if (existsSync5(join8(cwd, "bun.lock")) || existsSync5(join8(cwd, "bun.lockb"))) return "bun";
+  if (existsSync6(join8(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync6(join8(cwd, "yarn.lock"))) return "yarn";
+  if (existsSync6(join8(cwd, "bun.lock")) || existsSync6(join8(cwd, "bun.lockb"))) return "bun";
   return "npm";
 }
 function isPnpmWorkspaceRoot(cwd = process.cwd()) {
-  const target = resolve4(cwd);
+  const target = resolve5(cwd);
   let current = target;
   while (true) {
-    if (existsSync5(join8(current, "pnpm-workspace.yaml"))) return current === target;
+    if (existsSync6(join8(current, "pnpm-workspace.yaml"))) return current === target;
     const parent = dirname4(current);
     if (parent === current) return false;
     current = parent;
@@ -1831,7 +1908,7 @@ function renderConfig(options) {
 }
 function readPackageJson2(path) {
   try {
-    return JSON.parse(readFileSync6(path, "utf8"));
+    return JSON.parse(readFileSync7(path, "utf8"));
   } catch {
     return null;
   }
@@ -1899,7 +1976,7 @@ function initLocalghost(options = {}) {
   const packageManager = options.packageManager ?? detectPackageManager(cwd);
   const configFile = options.configFile ?? LOCALGHOST_CONFIG_FILE;
   const configPath = join8(cwd, configFile);
-  const configExists = existsSync5(configPath);
+  const configExists = existsSync6(configPath);
   if (configExists && !options.force) {
     return {
       configPath,
@@ -1920,7 +1997,7 @@ function initLocalghost(options = {}) {
   return {
     configPath,
     configCreated: true,
-    ...existsSync5(packageJsonPath) ? { packageJsonPath } : {},
+    ...existsSync6(packageJsonPath) ? { packageJsonPath } : {},
     packageJsonChanged,
     packageManager,
     nextSteps: [
@@ -2149,7 +2226,7 @@ function formatGhostTunnel(config, options = {}) {
 }
 
 // src/state.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 import { join as join9 } from "path";
 var LOCALGHOST_STATE_FILE = "ops/local/localghost-state.json";
 function getLocalghostStatePath(cwd = process.cwd()) {
@@ -2157,7 +2234,7 @@ function getLocalghostStatePath(cwd = process.cwd()) {
 }
 function readLocalghostState(cwd = process.cwd()) {
   const path = getLocalghostStatePath(cwd);
-  if (!existsSync6(path)) return null;
+  if (!existsSync7(path)) return null;
   return JSON.parse(readTextFile(path));
 }
 function writeLocalghostState(cwd, state) {
@@ -2173,11 +2250,11 @@ function patchLocalghostState(cwd, patch) {
 }
 
 // src/update-check.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
 import { homedir as homedir3 } from "os";
 import { dirname as dirname5, join as join10 } from "path";
 var LOCALGHOST_PACKAGE_NAME = "@hamedb89/localghost";
-var LOCALGHOST_VERSION = "0.5.0";
+var LOCALGHOST_VERSION = "0.6.2";
 var UPDATE_CHECK_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
 var UPDATE_CHECK_NOTIFY_TTL_MS = 24 * 60 * 60 * 1e3;
 var UPDATE_CHECK_TIMEOUT_MS = 900;
@@ -2193,9 +2270,9 @@ function getUpdateCheckCachePath(env = process.env) {
   return join10(cacheRoot, "localghost", "update-check.json");
 }
 function readCache(path = getUpdateCheckCachePath()) {
-  if (!existsSync7(path)) return null;
+  if (!existsSync8(path)) return null;
   try {
-    return JSON.parse(readFileSync7(path, "utf8"));
+    return JSON.parse(readFileSync8(path, "utf8"));
   } catch {
     return null;
   }
@@ -2345,7 +2422,7 @@ import { execa as execa4 } from "execa";
 
 // src/process.ts
 function signalManagedProcessPid(pid, signal, killProcess = (value, processSignal) => process.kill(value, processSignal)) {
-  if (typeof pid !== "number" || !Number.isInteger(pid) || pid < 1) return false;
+  if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 1 || pid === process.pid) return false;
   try {
     killProcess(process.platform === "win32" ? pid : -pid, signal);
     return true;
@@ -2519,7 +2596,7 @@ function getSetupReadiness(options) {
   }
   const hostsPath = getSystemHostsPath();
   try {
-    const hosts = readFileSync8(hostsPath, "utf8");
+    const hosts = readFileSync9(hostsPath, "utf8");
     const expectedHostsBlock = renderHostsBlock(projectName, entries).trimEnd();
     if (!hosts.includes(expectedHostsBlock)) {
       reasons.push(`The Localghost hosts block in ${hostsPath} is missing or stale.`);
@@ -2529,11 +2606,11 @@ function getSetupReadiness(options) {
     reasons.push(`Could not read ${hostsPath}: ${message}`);
   }
   if (!options.ignoreCaddyfile) {
-    if (!existsSync8(caddyfilePath)) {
+    if (!existsSync9(caddyfilePath)) {
       reasons.push(`Missing Caddyfile at ${caddyfilePath}.`);
     } else {
       const expectedCaddyfile = renderCaddyfile(entries, { https });
-      const currentCaddyfile = readFileSync8(caddyfilePath, "utf8");
+      const currentCaddyfile = readFileSync9(caddyfilePath, "utf8");
       if (currentCaddyfile !== expectedCaddyfile) {
         reasons.push(`Caddyfile at ${caddyfilePath} is stale for ${https ? "HTTPS" : "HTTP"} mode.`);
       }
@@ -2578,7 +2655,7 @@ async function runSetupFromReadiness(cwd, https, readiness) {
   });
 }
 function wait2(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
 }
 async function runTrust(cwd, caddyfilePath) {
   await wait2(350);
@@ -2697,10 +2774,13 @@ function registerSignalShutdown(stop) {
   };
   process.once("SIGINT", request);
   process.once("SIGTERM", request);
-  return () => {
-    process.off("SIGINT", request);
-    process.off("SIGTERM", request);
-    request();
+  return {
+    wasRequested: () => requested,
+    finish: () => {
+      process.off("SIGINT", request);
+      process.off("SIGTERM", request);
+      if (!requested) stop();
+    }
   };
 }
 async function resolveServiceRuntimeEntries(services, dynamicPort, projectCwd) {
@@ -2752,11 +2832,22 @@ async function waitForPortsToBeAvailable(entries, timeoutMs = 1e4) {
   const deadline = Date.now() + timeoutMs;
   const ports = [...new Set(entries.map((entry) => entry.port))];
   while (Date.now() < deadline) {
-    const availability = await Promise.all(ports.map((port) => isPortAvailable(port)));
-    if (availability.every(Boolean)) return true;
+    const availability2 = await Promise.all(ports.map((port) => isPortAvailable(port)));
+    if (availability2.every(Boolean)) return { available: true, blocked: [] };
     await wait2(50);
   }
-  return false;
+  const availability = await Promise.all(entries.map(async (entry) => ({
+    entry,
+    available: await isPortAvailable(entry.port)
+  })));
+  const blocked = availability.filter(({ available }) => !available).map(({ entry }) => entry);
+  return { available: blocked.length === 0, blocked };
+}
+function formatBlockedPorts(entries) {
+  return [...new Map(entries.map((entry) => [
+    `${entry.host}:${entry.port}`,
+    `${entry.host} (port ${entry.port})`
+  ])).values()].join(", ");
 }
 async function waitForProcessShutdown(processes, forceStop, timeoutMs = 1e4) {
   const settled = Promise.allSettled(processes);
@@ -2847,7 +2938,7 @@ async function runDetectedServices(options) {
       }
       signalManagedProcess(caddy, signal);
     };
-    const finishShutdown = registerSignalShutdown(() => stopManaged("SIGINT"));
+    const shutdown = registerSignalShutdown(() => stopManaged("SIGINT"));
     try {
       const ready = await Promise.race([
         waitForServicePorts(entries),
@@ -2859,15 +2950,18 @@ async function runDetectedServices(options) {
       }
       await processExit;
     } finally {
-      finishShutdown();
+      shutdown.finish();
       await waitForProcessShutdown(
         [caddyExit, ...children],
         stopManaged
       );
-      if (!await waitForPortsToBeAvailable(entries)) {
-        console.warn("Localghost: timed out waiting for service ports to be released.");
+      const drained = await waitForPortsToBeAvailable(entries);
+      if (!drained.available && !shutdown.wasRequested()) {
+        console.warn(`Localghost: timed out waiting for service ports to be released: ${formatBlockedPorts(drained.blocked)}.`);
         stopManaged("SIGTERM");
-        if (!await waitForPortsToBeAvailable(entries, 2e3)) {
+        const terminated = await waitForPortsToBeAvailable(entries, 2e3);
+        if (!terminated.available) {
+          console.warn(`Localghost: service ports still occupied after termination: ${formatBlockedPorts(terminated.blocked)}.`);
           stopManaged("SIGKILL");
         }
       }
@@ -3193,13 +3287,13 @@ program.command("reset").description("Remove Localghost setup state without dele
   const statePath = getLocalghostStatePath(options.cwd);
   explainHostsPassword();
   const hostsResult = await removeSystemHosts(projectName);
-  if (existsSync8(caddyfilePath)) {
+  if (existsSync9(caddyfilePath)) {
     unlinkSync(caddyfilePath);
     console.log(`Removed ${caddyfilePath}`);
   } else {
     console.log(`${caddyfilePath} was not present`);
   }
-  if (existsSync8(statePath)) {
+  if (existsSync9(statePath)) {
     unlinkSync(statePath);
     console.log(`Removed ${statePath}`);
   } else {
@@ -3220,7 +3314,7 @@ program.command("teardown").description("Remove Localghost's managed /etc/hosts
   const hostsResult = await removeSystemHosts(projectName);
   const caddyfilePath = getCaddyfilePath(options.cwd);
   let caddyfileRemoved = false;
-  if (options.removeCaddyfile && existsSync8(caddyfilePath)) {
+  if (options.removeCaddyfile && existsSync9(caddyfilePath)) {
     unlinkSync(caddyfilePath);
     caddyfileRemoved = true;
   }
@@ -3245,6 +3339,15 @@ program.command("teardown").description("Remove Localghost's managed /etc/hosts
   unregisterLocalghostSetup({ cwd: options.cwd, projectName });
   console.log(`State ${statePath}`);
 });
+program.command("ports").description("Manage Localghost port registry state").addCommand(new Command("prune").description("Remove expired or dead port leases").option("--cwd <path>", "Project directory", process.cwd()).option("--test-only", "Remove only stale test-session leases and records").option("--json", "Print raw JSON").action(async (options) => {
+  const result = options.testOnly ? await createLocalghostRegistry({ cwd: options.cwd }).pruneTestSessions() : await createLocalghostRegistry({ cwd: options.cwd }).prune();
+  if (options.json) console.log(JSON.stringify(result, null, 2));
+  else console.log(`Pruned ${result.removedLeases} stale registry lease${result.removedLeases === 1 ? "" : "s"}${"removedAllocations" in result ? ` and ${result.removedAllocations} test allocation${result.removedAllocations === 1 ? "" : "s"}` : ""}.`);
+})).addCommand(new Command("reset").description("Clear all remembered allocations and leases").option("--cwd <path>", "Project directory", process.cwd()).option("--yes", "Confirm the destructive registry reset").action(async (options) => {
+  if (!options.yes) throw new Error("Resetting the port registry is destructive. Re-run with --yes.");
+  await createLocalghostRegistry({ cwd: options.cwd }).reset();
+  console.log("Localghost port registry reset.");
+}));
 program.command("test").description("Run a test command with an isolated Localghost port").option("--cwd <path>", "Project directory", process.cwd()).option("--instance <name>", "Parallel test instance name", String(process.pid)).option("--port <number>", "Initial test port", parsePort2, 5173).option("--lease-ttl <milliseconds>", "Lease lifetime before heartbeat renewal", Number, 30 * 60 * 1e3).argument("<command...>", "Command to run after --").action(async (command, options) => {
   const [binary, ...args] = command;
   if (!binary) throw new Error("Missing command. Use: localghost test -- <command>");
@@ -3524,19 +3627,22 @@ program.command("run").description("Run Caddy and a dev command from the same Lo
       signalManagedProcess(child, signal);
       signalManagedProcess(caddy, signal);
     };
-    const finishShutdown = registerSignalShutdown(() => stopManaged("SIGINT"));
+    const shutdown = registerSignalShutdown(() => stopManaged("SIGINT"));
     try {
       await Promise.race([child, caddyExit]);
     } finally {
-      finishShutdown();
+      shutdown.finish();
       await waitForProcessShutdown(
         [child, caddyExit],
         stopManaged
       );
-      if (!await waitForPortsToBeAvailable(context.entries)) {
-        console.warn("Localghost: timed out waiting for service ports to be released.");
+      const drained = await waitForPortsToBeAvailable(context.entries);
+      if (!drained.available && !shutdown.wasRequested()) {
+        console.warn(`Localghost: timed out waiting for service ports to be released: ${formatBlockedPorts(drained.blocked)}.`);
         stopManaged("SIGTERM");
-        if (!await waitForPortsToBeAvailable(context.entries, 2e3)) {
+        const terminated = await waitForPortsToBeAvailable(context.entries, 2e3);
+        if (!terminated.available) {
+          console.warn(`Localghost: service ports still occupied after termination: ${formatBlockedPorts(terminated.blocked)}.`);
           stopManaged("SIGKILL");
         }
       }