@hamedb89/localghost 0.1.13 → 0.2.0

package/dist/vite.d.ts

@@ -17,6 +17,7 @@ type LocalGhostPluginOptions = {
     localghostConfig?: string | false;
     wwwAlias?: boolean;
     ghostTunnel?: GhostTunnelOptions;
+    registryOwnerToken?: string;
     verbose?: boolean;
 };
 declare function localGhostPlugin(options?: LocalGhostPluginOptions): Plugin;

package/dist/vite.js

@@ -1,6 +1,6 @@
 // src/vite.ts
 import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
-import { normalize, resolve as resolve2 } from "path";
+import { normalize as normalize2, resolve as resolve3 } from "path";
 import { spawn } from "child_process";
 import { emitKeypressEvents } from "readline";
 
@@ -80,6 +80,7 @@ function registerLocalghostRun(input2, path = getLocalghostActivityPath()) {
     ...input2.configPath ? { configPath: input2.configPath } : {},
     ...input2.caddyfilePath ? { caddyfilePath: input2.caddyfilePath } : {},
     ...input2.caddyPid ? { caddyPid: input2.caddyPid } : {},
+    ...input2.caddyPgid ? { caddyPgid: input2.caddyPgid } : {},
     ...input2.childPid ? { childPid: input2.childPid } : {},
     ...input2.childCommand ? { childCommand: input2.childCommand } : {},
     ...typeof input2.https === "boolean" ? { https: input2.https } : {},
@@ -229,25 +230,30 @@ function getProjectName(cwd = process.cwd()) {
   }
 }
 function sanitizeProjectName(value) {
-  const projectName = value.replace(/[^\w.-]+/g, "-").replace(/^-+|-+$/g, "");
+  const sanitized = value.replace(/[^\w.-]+/g, "-");
+  let start = 0;
+  let end = sanitized.length;
+  while (start < end && sanitized.charCodeAt(start) === 45) start += 1;
+  while (end > start && sanitized.charCodeAt(end - 1) === 45) end -= 1;
+  const projectName = sanitized.slice(start, end);
   return projectName || "app";
 }
 
 // src/context.ts
 import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
-import { join as join3 } from "path";
+import { join as join4 } 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((resolve3) => {
+  return new Promise((resolve4) => {
     const server = createServer();
     server.once("error", () => {
-      resolve3(false);
+      resolve4(false);
     });
     server.once("listening", () => {
-      server.close(() => resolve3(true));
+      server.close(() => resolve4(true));
     });
     server.listen(port, host);
   });
@@ -264,6 +270,188 @@ async function findAvailablePort(startPort, options = {}) {
   throw new Error(`No available port found from ${startPort} to ${startPort + maxAttempts - 1}.`);
 }
 
+// src/registry.ts
+import { randomUUID } from "crypto";
+import { mkdir, open, readFile, rename, rm, stat, unlink, writeFile } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { join as join3, normalize, resolve as resolve2 } from "path";
+var LOCALGHOST_REGISTRY_FILE = "registry.json";
+var LOCALGHOST_REGISTRY_LOCK_FILE = "registry.lock";
+function defaultProcessRunning(pid) {
+  if (pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function getLocalghostRegistryRoot(env = process.env) {
+  return resolve2(env.LOCALGHOST_HOME || join3(homedir2(), ".localghost"));
+}
+function canonicalizeLocalghostProjectCwd(cwd = process.cwd()) {
+  return normalize(resolve2(cwd));
+}
+function emptyRegistry() {
+  return { version: 1, allocations: [], leases: [] };
+}
+function leaseKey(projectCwd, instanceKey) {
+  return `${projectCwd}\0${instanceKey}`;
+}
+function validRegistry(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return candidate.version === 1 && Array.isArray(candidate.allocations) && Array.isArray(candidate.leases);
+}
+function pruneRegistry(registry, now, isRunning) {
+  registry.leases = registry.leases.filter((lease) => lease.expiresAt > now && isRunning(lease.pid));
+}
+async function readJson(path) {
+  try {
+    return JSON.parse(await readFile(path, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    return void 0;
+  }
+}
+function createLocalghostRegistry(options = {}) {
+  const root = resolve2(options.stateRoot ?? getLocalghostRegistryRoot());
+  const registryPath = join3(root, LOCALGHOST_REGISTRY_FILE);
+  const lockPath = join3(root, LOCALGHOST_REGISTRY_LOCK_FILE);
+  const cwd = canonicalizeLocalghostProjectCwd(options.cwd);
+  const now = options.now ?? Date.now;
+  const pid = options.pid ?? process.pid;
+  const ownerToken = options.ownerToken ?? randomUUID();
+  const isRunning = options.isProcessRunning ?? defaultProcessRunning;
+  const availabilityCheck = options.availabilityCheck ?? isPortAvailable;
+  const lockTimeoutMs = options.lockTimeoutMs ?? 5e3;
+  const lockRetryMs = options.lockRetryMs ?? 25;
+  const lockStaleMs = options.lockStaleMs ?? 3e4;
+  async function readRegistry() {
+    const value = await readJson(registryPath);
+    return validRegistry(value) ? value : emptyRegistry();
+  }
+  async function writeRegistry(registry) {
+    await mkdir(root, { recursive: true });
+    const temporaryPath = join3(root, `.registry.${process.pid}.${randomUUID()}.tmp`);
+    await writeFile(temporaryPath, `${JSON.stringify(registry, null, 2)}
+`, { mode: 384 });
+    await rename(temporaryPath, registryPath);
+  }
+  async function lock() {
+    await mkdir(root, { recursive: true });
+    const deadline = now() + lockTimeoutMs;
+    const token = randomUUID();
+    while (true) {
+      try {
+        const handle = await open(lockPath, "wx", 384);
+        await handle.writeFile(`${JSON.stringify({ pid, createdAt: now(), token })}
+`);
+        await handle.close();
+        return async () => {
+          const current = await readJson(lockPath);
+          if (current?.token === token) await unlink(lockPath).catch(() => void 0);
+        };
+      } catch (error) {
+        if (error.code !== "EEXIST") throw error;
+        const lockInfo = await readJson(lockPath);
+        let stale = false;
+        if (lockInfo && typeof lockInfo.pid === "number") {
+          stale = !isRunning(lockInfo.pid) && now() - lockInfo.createdAt >= 0;
+        } else {
+          try {
+            stale = now() - (await stat(lockPath)).mtimeMs > lockStaleMs;
+          } catch {
+            continue;
+          }
+        }
+        if (stale) {
+          await rm(lockPath, { force: true }).catch(() => void 0);
+          continue;
+        }
+        if (now() >= deadline) throw new Error(`Timed out waiting for Localghost registry lock: ${lockPath}`);
+        await new Promise((resolveDelay) => setTimeout(resolveDelay, lockRetryMs));
+      }
+    }
+  }
+  async function withLock(operation) {
+    const releaseLock = await lock();
+    try {
+      const registry = await readRegistry();
+      pruneRegistry(registry, now(), isRunning);
+      return await operation(registry);
+    } finally {
+      await releaseLock();
+    }
+  }
+  return {
+    root,
+    registryPath,
+    lockPath,
+    ownerToken,
+    read: readRegistry,
+    async prune() {
+      const releaseLock = await lock();
+      try {
+        const registry = await readRegistry();
+        const before = registry.leases.length;
+        pruneRegistry(registry, now(), isRunning);
+        await writeRegistry(registry);
+        return { removedLeases: before - registry.leases.length };
+      } finally {
+        await releaseLock();
+      }
+    },
+    async acquirePort(acquireOptions) {
+      const projectCwd = canonicalizeLocalghostProjectCwd(acquireOptions.projectCwd ?? cwd);
+      if (!acquireOptions.instanceKey) throw new Error("instanceKey is required");
+      return withLock(async (registry) => {
+        const key = leaseKey(projectCwd, acquireOptions.instanceKey);
+        const existing = registry.allocations.find((entry2) => leaseKey(entry2.projectCwd, entry2.instanceKey) === key);
+        const reserved = new Set(acquireOptions.reservedPorts ?? []);
+        const activePorts = new Set(registry.leases.map((lease2) => lease2.port));
+        const port = existing?.port;
+        const ownsActiveLease = registry.leases.some((lease2) => lease2.port === port && leaseKey(lease2.projectCwd, lease2.instanceKey) === key && lease2.ownerToken === ownerToken);
+        const reusable = port !== void 0 && !reserved.has(port) && (!activePorts.has(port) || ownsActiveLease) && (ownsActiveLease || await availabilityCheck(port, acquireOptions.host));
+        let selectedPort = reusable ? port : void 0;
+        if (selectedPort === void 0) {
+          const startPort = acquireOptions.startPort ?? 3e3;
+          const maxAttempts = acquireOptions.maxAttempts ?? 50;
+          for (let offset = 0; offset < maxAttempts; offset += 1) {
+            const candidate = startPort + offset;
+            if (reserved.has(candidate) || activePorts.has(candidate)) continue;
+            if (await availabilityCheck(candidate, acquireOptions.host)) {
+              selectedPort = candidate;
+              break;
+            }
+          }
+          if (selectedPort === void 0) throw new Error(`No available registry port found from ${startPort} to ${startPort + maxAttempts - 1}.`);
+        }
+        const timestamp = now();
+        const entry = existing ?? { projectCwd, instanceKey: acquireOptions.instanceKey, port: selectedPort, updatedAt: timestamp };
+        entry.port = selectedPort;
+        entry.updatedAt = timestamp;
+        if (!existing) registry.allocations.push(entry);
+        registry.leases = registry.leases.filter((lease2) => leaseKey(lease2.projectCwd, lease2.instanceKey) !== key);
+        const lease = { projectCwd, instanceKey: acquireOptions.instanceKey, port: selectedPort, pid, acquiredAt: timestamp, expiresAt: timestamp + (acquireOptions.leaseTtlMs ?? 30 * 60 * 1e3), ownerToken };
+        registry.leases.push(lease);
+        await writeRegistry(registry);
+        return lease;
+      });
+    },
+    async releasePort(releaseOptions) {
+      const projectCwd = canonicalizeLocalghostProjectCwd(releaseOptions.projectCwd ?? cwd);
+      return withLock(async (registry) => {
+        const key = leaseKey(projectCwd, releaseOptions.instanceKey);
+        const before = registry.leases.length;
+        registry.leases = registry.leases.filter((lease) => leaseKey(lease.projectCwd, lease.instanceKey) !== key || lease.ownerToken !== ownerToken);
+        if (registry.leases.length !== before) await writeRegistry(registry);
+        return registry.leases.length !== before;
+      });
+    }
+  };
+}
+
 // src/tunnel.ts
 import { domainToASCII } from "url";
 var DEFAULT_GHOST_TUNNEL_SUBDOMAIN = "ghost";
@@ -641,7 +829,7 @@ function envHttps() {
 }
 function getPackageName(cwd) {
   try {
-    const pkg = JSON.parse(readFileSync3(join3(cwd, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync3(join4(cwd, "package.json"), "utf8"));
     return typeof pkg.name === "string" ? pkg.name : void 0;
   } catch {
     return void 0;
@@ -724,7 +912,24 @@ async function resolveLocalghostContext(options = {}) {
   const autoRepair = merged.autoRepair ?? true;
   const bindHost = merged.bindHost ?? "127.0.0.1";
   const probeHost = typeof bindHost === "string" ? bindHost : "127.0.0.1";
-  const port = dynamicPort ? await findAvailablePort(requestedPort, { host: probeHost }) : requestedPort;
+  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);
@@ -753,7 +958,8 @@ async function resolveLocalghostContext(options = {}) {
     https: merged.https ?? envHttps() ?? false,
     wwwAlias,
     ghostTunnel,
-    ...projectConfig.path ? { projectConfigPath: projectConfig.path } : {}
+    ...projectConfig.path ? { projectConfigPath: projectConfig.path } : {},
+    ...releasePort ? { releasePort } : {}
   };
 }
 
@@ -806,7 +1012,7 @@ function writeTextFile(path, value) {
 // src/hosts-file.ts
 import { writeFileSync as writeFileSync3 } from "fs";
 import { tmpdir } from "os";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 import { execa as execa2 } from "execa";
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -842,7 +1048,7 @@ ${block}`;
 }
 async function writeSystemHostsFile(hostsPath, next, projectName) {
   const sanitizedProjectName = sanitizeProjectName(projectName);
-  const tempPath = join4(tmpdir(), `localghost-${sanitizedProjectName}-hosts`);
+  const tempPath = join5(tmpdir(), `localghost-${sanitizedProjectName}-hosts`);
   writeFileSync3(tempPath, next, "utf8");
   if (process.env.LOCALGHOST_HOSTS_PATH) {
     writeFileSync3(hostsPath, next, "utf8");
@@ -899,10 +1105,10 @@ async function ask(question, defaultValue) {
 
 // src/state.ts
 import { existsSync as existsSync4 } from "fs";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 var LOCALGHOST_STATE_FILE = "ops/local/localghost-state.json";
 function getLocalghostStatePath(cwd = process.cwd()) {
-  return join5(cwd, LOCALGHOST_STATE_FILE);
+  return join6(cwd, LOCALGHOST_STATE_FILE);
 }
 function readLocalghostState(cwd = process.cwd()) {
   const path = getLocalghostStatePath(cwd);
@@ -917,7 +1123,7 @@ function writeLocalghostState(cwd, state) {
 }
 
 // src/caddy.ts
-import { dirname as dirname3, join as join6 } from "path";
+import { dirname as dirname3, join as join7 } from "path";
 import { execa as execa3 } from "execa";
 function shouldShowCaddyLogs() {
   return ["1", "true", "yes", "on"].includes((process.env.LOCALGHOST_CADDY_VERBOSE ?? "").toLowerCase());
@@ -935,7 +1141,7 @@ function groupByPort(entries) {
   return groups;
 }
 function getCaddyfilePath(cwd = process.cwd()) {
-  return join6(cwd, "ops/local/Caddyfile");
+  return join7(cwd, "ops/local/Caddyfile");
 }
 function renderCaddyfile(entries, options = {}) {
   const groups = groupByPort(entries);
@@ -1073,12 +1279,12 @@ function getConfigWatchFiles(options) {
   const readOptions = readOptionsFromPlugin(options);
   const cwd = readOptions.cwd ?? process.cwd();
   const resolvedPath = resolveDevHostsPath(readOptions);
-  const candidatePaths = getConfigFileCandidates(readOptions).map((fileName) => resolve2(cwd, fileName));
-  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));
+  const candidatePaths = getConfigFileCandidates(readOptions).map((fileName) => resolve3(cwd, fileName));
+  const projectConfigPaths = options.localghostConfig === false ? [] : options.localghostConfig ? [resolve3(cwd, options.localghostConfig)] : ["localghost.config.mjs", "localghost.config.js", "localghost.config.cjs"].map((fileName) => resolve3(cwd, fileName));
   return [.../* @__PURE__ */ new Set([...candidatePaths, resolvedPath.path, ...projectConfigPaths])];
 }
 function normalizeWatchPath(filePath) {
-  return normalize(resolve2(filePath));
+  return normalize2(resolve3(filePath));
 }
 function renderConfig(hosts, port) {
   return [
@@ -1094,7 +1300,7 @@ function defaultHost(cwd) {
 }
 function getPackageOwner2(cwd) {
   try {
-    const pkg = JSON.parse(readFileSync5(resolve2(cwd, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync5(resolve3(cwd, "package.json"), "utf8"));
     if (typeof pkg.name === "string" && pkg.name.startsWith("@")) {
       return pkg.name.slice(1).split("/")[0];
     }
@@ -1219,10 +1425,15 @@ async function ensureLocalghostContext(options, vitePort, https) {
     writeTextFile(resolved.path, renderConfig(hosts, vitePort));
     console.log(`Created ${resolved.path}`);
   }
+  const wrapperManagedPort = Boolean(process.env.LOCALGHOST_PORT);
   const context = await resolveLocalghostContext({
     ...options,
     cwd,
     port: vitePort,
+    reservePort: !wrapperManagedPort,
+    instanceKey: "vite",
+    registryOwnerToken: options.registryOwnerToken ?? `${process.pid}:vite:${cwd}`,
+    ...wrapperManagedPort ? { dynamicPort: false } : {},
     ...typeof https === "boolean" ? { https } : {}
   });
   if (!hasReadySetup(cwd, context.entries, resolved.path, context.https)) {
@@ -1420,6 +1631,7 @@ function localGhostPlugin(options = {}) {
       const cleanup = () => {
         cleanupActivity();
         cleanupGhostMenu?.();
+        void resolvedContext?.releasePort?.();
       };
       server.httpServer?.once("close", cleanup);
       process.once("exit", cleanup);