@hamedb89/localghost 0.1.0 → 0.1.6

package/dist/index.js

@@ -1,6 +1,100 @@
+// 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: [] };
+}
+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 : []
+    };
+  } 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(input, pid) {
+  return `${input.projectName}:${input.mode}:${pid}:${Date.now()}`;
+}
+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({ version: LOCALGHOST_ACTIVITY_VERSION, runs: activeRuns }, path);
+  }
+  return {
+    path,
+    pruned,
+    runs: activeRuns
+  };
+}
+function listLocalghostRuns(path = getLocalghostActivityPath()) {
+  return pruneLocalghostActivity(path).runs;
+}
+function registerLocalghostRun(input, path = getLocalghostActivityPath()) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const pid = input.pid ?? process.pid;
+  const record = {
+    id: input.id ?? createRunId(input, pid),
+    mode: input.mode,
+    pid,
+    cwd: input.cwd,
+    projectName: input.projectName,
+    startedAt: input.startedAt ?? now,
+    updatedAt: now,
+    ...input.configPath ? { configPath: input.configPath } : {},
+    ...input.caddyfilePath ? { caddyfilePath: input.caddyfilePath } : {},
+    ...input.caddyPid ? { caddyPid: input.caddyPid } : {},
+    ...input.childPid ? { childPid: input.childPid } : {},
+    ...input.childCommand ? { childCommand: input.childCommand } : {},
+    ...typeof input.https === "boolean" ? { https: input.https } : {},
+    ...input.requestedPort ? { requestedPort: input.requestedPort } : {},
+    ...input.port ? { port: input.port } : {},
+    ...typeof input.dynamicPort === "boolean" ? { dynamicPort: input.dynamicPort } : {},
+    entries: input.entries
+  };
+  const current = pruneLocalghostActivity(path).runs.filter((run) => run.id !== record.id);
+  writeLocalghostActivity({ version: LOCALGHOST_ACTIVITY_VERSION, runs: [...current, 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({ 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;
@@ -68,7 +162,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),
@@ -104,11 +198,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 {
@@ -121,18 +215,18 @@ function sanitizeProjectName(value) {
 }
 
 // src/caddy.ts
-import { dirname as dirname2, join as join2 } from "path";
+import { dirname as dirname3, join as join3 } from "path";
 import { execa } from "execa";
 
 // src/fs.ts
-import { mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
-import { dirname } from "path";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2 } from "path";
 function readTextFile(path) {
-  return readFileSync2(path, "utf8");
+  return readFileSync3(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;
 }
 
@@ -147,41 +241,140 @@ function groupByPort(entries) {
   return groups;
 }
 function getCaddyfilePath(cwd = process.cwd()) {
-  return join2(cwd, "ops/local/Caddyfile");
+  return join3(cwd, "ops/local/Caddyfile");
 }
-function renderCaddyfile(entries) {
+function renderCaddyfile(entries, options = {}) {
   const groups = groupByPort(entries);
+  const https = options.https === true;
   const blocks = [...groups.entries()].sort(([leftPort], [rightPort]) => leftPort - rightPort).map(([port, group]) => {
-    const hosts = group.map((entry) => entry.host).sort().join(", ");
+    const hosts = group.map((entry) => https ? entry.host : `http://${entry.host}`).sort().join(", ");
     return `${hosts} {
   reverse_proxy 127.0.0.1:${port}
 }`;
   });
-  return `{
+  const globalOptions = https ? `{
   local_certs
 }
 
-${blocks.join("\n\n")}
+` : "";
+  return `${globalOptions}${blocks.join("\n\n")}
 `;
 }
-async function writeCaddyfile(entries, cwd = process.cwd()) {
+async function writeCaddyfile(entries, cwd = process.cwd(), options = {}) {
   const path = getCaddyfilePath(cwd);
-  writeTextFile(path, renderCaddyfile(entries));
+  writeTextFile(path, renderCaddyfile(entries, options));
   return path;
 }
 async function validateCaddyfile(path) {
   await execa("caddy", ["validate", "--config", path], {
-    cwd: dirname2(path),
+    cwd: dirname3(path),
     stdio: "inherit"
   });
 }
 async function runCaddy(path) {
   await execa("caddy", ["run", "--config", path], {
-    cwd: dirname2(path),
+    cwd: dirname3(path),
+    stdio: "inherit"
+  });
+}
+function startCaddy(path) {
+  return execa("caddy", ["run", "--config", path], {
+    cwd: dirname3(path),
     stdio: "inherit"
   });
 }
 
+// src/port.ts
+import { createServer } from "net";
+async function isPortAvailable(port, host = "127.0.0.1") {
+  return new Promise((resolve2) => {
+    const server = createServer();
+    server.once("error", () => {
+      resolve2(false);
+    });
+    server.once("listening", () => {
+      server.close(() => resolve2(true));
+    });
+    server.listen(port, host);
+  });
+}
+async function findAvailablePort(startPort, options = {}) {
+  const host = options.host ?? "127.0.0.1";
+  const maxAttempts = options.maxAttempts ?? 50;
+  for (let offset = 0; offset < maxAttempts; offset += 1) {
+    const port = startPort + offset;
+    if (await isPortAvailable(port, host)) {
+      return port;
+    }
+  }
+  throw new Error(`No available port found from ${startPort} to ${startPort + maxAttempts - 1}.`);
+}
+
+// src/context.ts
+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 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 } : entry);
+}
+function uniqueHosts(entries) {
+  return [...new Set(entries.map((entry) => entry.host))];
+}
+function defineLocalghostConfig(config) {
+  return config;
+}
+async function resolveLocalghostContext(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const readOptions = readOptionsFromContext({ ...options, 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 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 hosts = uniqueHosts(entries);
+  const primaryHost = options.primaryHost ?? entries.find((entry) => entry.port === port)?.host ?? hosts[0] ?? `${sanitizeProjectName(getProjectName(cwd))}.localhost`;
+  return {
+    cwd,
+    projectName: sanitizeProjectName(options.project ?? getProjectName(cwd)),
+    readOptions,
+    configPath: resolvedPath.path,
+    configFileName: resolvedPath.fileName,
+    configEntries,
+    entries,
+    hosts,
+    requestedPort,
+    port,
+    dynamicPort,
+    bindHost,
+    primaryHost,
+    https: options.https === true
+  };
+}
+
 // src/doctor.ts
 import { execa as execa2 } from "execa";
 async function checkCaddy() {
@@ -208,10 +401,34 @@ async function runDoctor() {
   };
 }
 
+// src/env.ts
+var PRODUCTION_ENV_KEYS = ["NODE_ENV", "VERCEL_ENV", "NETLIFY", "CF_PAGES_BRANCH", "LOCALGHOST_ENV"];
+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 isProductionLike(env = process.env) {
+  return getProductionReason(env) !== 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}.`);
+}
+function getProductionEnvKeys() {
+  return PRODUCTION_ENV_KEYS;
+}
+
 // src/hosts-file.ts
-import { writeFileSync as writeFileSync2 } from "fs";
+import { writeFileSync as writeFileSync3 } from "fs";
 import { tmpdir } from "os";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 import { execa as execa3 } from "execa";
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -253,8 +470,8 @@ function removeManagedBlock(existing, projectName) {
 }
 async function writeSystemHostsFile(hostsPath, next, projectName) {
   const sanitizedProjectName = sanitizeProjectName(projectName);
-  const tempPath = join3(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}.`);
   }
@@ -286,11 +503,11 @@ async function removeSystemHosts(projectName) {
 }
 
 // src/init.ts
-import { existsSync as existsSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { join as join5 } from "path";
 function detectPackageManager(cwd = process.cwd()) {
-  if (existsSync2(join4(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (existsSync2(join4(cwd, "yarn.lock"))) return "yarn";
+  if (existsSync3(join5(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync3(join5(cwd, "yarn.lock"))) return "yarn";
   return "npm";
 }
 function packageRunCommand(packageManager, script) {
@@ -315,7 +532,7 @@ function renderConfig(options) {
 }
 function readPackageJson(path) {
   try {
-    return JSON.parse(readFileSync3(path, "utf8"));
+    return JSON.parse(readFileSync4(path, "utf8"));
   } catch {
     return null;
   }
@@ -336,17 +553,24 @@ function updatePackageScripts(packageJsonPath, configFile) {
     ...scripts,
     "localghost:setup": scripts["localghost:setup"] ?? `localghost setup${configFlag}`,
     "localghost:proxy": scripts["localghost:proxy"] ?? `localghost dev${configFlag}`,
+    "localghost:proxy:https": scripts["localghost:proxy:https"] ?? `localghost dev${configFlag} --https`,
+    "localghost:run": scripts["localghost:run"] ?? `localghost run${configFlag} --`,
+    "localghost:ready": scripts["localghost:ready"] ?? `localghost status${configFlag} --ready`,
+    "localghost:ps": scripts["localghost:ps"] ?? "localghost ps",
     "localghost:print": scripts["localghost:print"] ?? `localghost print${configFlag}`,
     "localghost:routes": scripts["localghost:routes"] ?? `localghost routes${configFlag}`,
     "localghost:status": scripts["localghost:status"] ?? "localghost status",
+    "localghost:reset": scripts["localghost:reset"] ?? "localghost reset",
     "localghost:teardown": scripts["localghost:teardown"] ?? "localghost teardown",
     "localghost:doctor": scripts["localghost:doctor"] ?? "localghost doctor",
-    "localghost:update": scripts["localghost:update"] ?? "localghost update"
+    "localghost:update": scripts["localghost:update"] ?? "localghost update",
+    "caddy:setup": scripts["caddy:setup"] ?? `localghost setup${configFlag}`,
+    "caddy:dev": scripts["caddy:dev"] ?? `localghost dev${configFlag}`
   };
   const changed = JSON.stringify(scripts) !== JSON.stringify(nextScripts);
   if (!changed) return false;
   pkg.scripts = nextScripts;
-  writeFileSync3(packageJsonPath, `${JSON.stringify(pkg, null, 2)}
+  writeFileSync4(packageJsonPath, `${JSON.stringify(pkg, null, 2)}
 `, "utf8");
   return true;
 }
@@ -359,8 +583,8 @@ function initLocalghost(options = {}) {
   const apiPort = options.apiPort ?? 8787;
   const packageManager = options.packageManager ?? detectPackageManager(cwd);
   const configFile = options.configFile ?? LOCALGHOST_CONFIG_FILE;
-  const configPath = join4(cwd, configFile);
-  const configExists = existsSync2(configPath);
+  const configPath = join5(cwd, configFile);
+  const configExists = existsSync3(configPath);
   if (configExists && !options.force) {
     return {
       configPath,
@@ -370,22 +594,24 @@ function initLocalghost(options = {}) {
       nextSteps: [
         packageRunCommand(packageManager, "localghost:doctor"),
         packageRunCommand(packageManager, "localghost:setup"),
+        packageRunCommand(packageManager, "localghost:ready"),
         packageRunCommand(packageManager, "localghost:proxy")
       ]
     };
   }
   writeTextFile(configPath, renderConfig({ host, port, apiHost, apiPort }));
-  const packageJsonPath = join4(cwd, "package.json");
+  const packageJsonPath = join5(cwd, "package.json");
   const packageJsonChanged = options.writeScripts ? updatePackageScripts(packageJsonPath, configFile) : false;
   return {
     configPath,
     configCreated: true,
-    ...existsSync2(packageJsonPath) ? { packageJsonPath } : {},
+    ...existsSync3(packageJsonPath) ? { packageJsonPath } : {},
     packageJsonChanged,
     packageManager,
     nextSteps: [
       packageRunCommand(packageManager, "localghost:doctor"),
       packageRunCommand(packageManager, "localghost:setup"),
+      packageRunCommand(packageManager, "localghost:ready"),
       packageRunCommand(packageManager, "localghost:proxy")
     ]
   };
@@ -393,7 +619,7 @@ function initLocalghost(options = {}) {
 
 // src/routes.ts
 function getDomainRoutes(entries, options = {}) {
-  const protocol = options.https === false ? "http" : "https";
+  const protocol = options.https === true ? "https" : "http";
   return [...entries].sort((left, right) => left.host.localeCompare(right.host) || left.port - right.port).map((entry) => ({
     host: entry.host,
     port: entry.port,
@@ -413,15 +639,15 @@ function formatDomainRoutes(entries, options = {}) {
 }
 
 // src/state.ts
-import { existsSync as existsSync3 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync4 } from "fs";
+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);
-  if (!existsSync3(path)) return null;
+  if (!existsSync4(path)) return null;
   return JSON.parse(readTextFile(path));
 }
 function writeLocalghostState(cwd, state) {
@@ -432,11 +658,11 @@ function writeLocalghostState(cwd, state) {
 }
 
 // src/update-check.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
-import { homedir } from "os";
-import { dirname as dirname3, join as join6 } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname4, join as join7 } from "path";
 var LOCALGHOST_PACKAGE_NAME = "@hamedb89/localghost";
-var LOCALGHOST_VERSION = "0.1.0";
+var LOCALGHOST_VERSION = "0.1.6";
 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;
@@ -448,21 +674,21 @@ function isUpdateCheckDisabled(env = process.env) {
 }
 function getUpdateCheckCachePath(env = process.env) {
   if (env.LOCALGHOST_UPDATE_CHECK_CACHE) return env.LOCALGHOST_UPDATE_CHECK_CACHE;
-  const cacheRoot = env.XDG_CACHE_HOME || join6(homedir(), ".cache");
-  return join6(cacheRoot, "localghost", "update-check.json");
+  const cacheRoot = env.XDG_CACHE_HOME || join7(homedir2(), ".cache");
+  return join7(cacheRoot, "localghost", "update-check.json");
 }
 function readCache(path = getUpdateCheckCachePath()) {
-  if (!existsSync4(path)) return null;
+  if (!existsSync5(path)) return null;
   try {
-    return JSON.parse(readFileSync4(path, "utf8"));
+    return JSON.parse(readFileSync5(path, "utf8"));
   } catch {
     return null;
   }
 }
 function writeCache(cache, path = getUpdateCheckCachePath()) {
   try {
-    mkdirSync2(dirname3(path), { recursive: true });
-    writeFileSync4(path, `${JSON.stringify(cache, null, 2)}
+    mkdirSync3(dirname4(path), { recursive: true });
+    writeFileSync5(path, `${JSON.stringify(cache, null, 2)}
 `, "utf8");
   } catch {
   }
@@ -598,6 +824,7 @@ ${message}`);
   markUpdateNotified(result, cachePath);
 }
 export {
+  LOCALGHOST_ACTIVITY_VERSION,
   LOCALGHOST_CONFIG_FILE,
   LOCALGHOST_PACKAGE_NAME,
   LOCALGHOST_STATE_FILE,
@@ -605,10 +832,13 @@ export {
   UPDATE_CHECK_CACHE_TTL_MS,
   UPDATE_CHECK_NOTIFY_TTL_MS,
   UPDATE_CHECK_TIMEOUT_MS,
+  assertLocalDevelopment,
   checkCaddy,
   checkForUpdate,
   compareVersions,
+  defineLocalghostConfig,
   detectPackageManager,
+  findAvailablePort,
   findLocalMdnsHosts,
   formatDomainRoutes,
   formatUpdateMessage,
@@ -616,33 +846,47 @@ export {
   getConfigFileCandidates,
   getDevHostsPath,
   getDomainRoutes,
+  getLocalghostActivityPath,
   getLocalghostStatePath,
+  getProductionEnvKeys,
+  getProductionReason,
   getProjectName,
   getSystemHostsPath,
   getUpdateCheckCachePath,
   initLocalghost,
   isNewerVersion,
+  isPortAvailable,
+  isProcessRunning,
+  isProductionLike,
   isUpdateCheckDisabled,
+  listLocalghostRuns,
   markUpdateNotified,
   maybeNotifyAboutUpdate,
   packageAddCommand,
   packageRunCommand,
   parseDevHosts,
+  pruneLocalghostActivity,
   readDevHosts,
+  readLocalghostActivity,
   readLocalghostState,
+  registerLocalghostRun,
   removeManagedBlock,
   removeSystemHosts,
   renderCaddyfile,
   renderHostsBlock,
   resolveDevHostsPath,
+  resolveLocalghostContext,
   runCaddy,
   runDoctor,
   sanitizeProjectName,
   shouldNotifyAboutUpdate,
+  startCaddy,
+  unregisterLocalghostRun,
   updateSystemHosts,
   upsertManagedBlock,
   validateCaddyfile,
   writeCaddyfile,
+  writeLocalghostActivity,
   writeLocalghostState
 };
 //# sourceMappingURL=index.js.map