@hamedb89/localghost 0.5.0 → 0.6.1

package/dist/cli.js

@@ -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");
@@ -2177,7 +2211,7 @@ import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as rea
 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.1";
 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;
@@ -2345,7 +2379,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;
@@ -2697,10 +2731,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 +2789,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 +2895,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 +2907,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");
         }
       }
@@ -3245,6 +3296,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 +3584,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");
         }
       }