@hamedb89/localghost 0.1.8 → 0.1.10

package/docs/ghost-tunnel.md

@@ -0,0 +1,293 @@
+# Ghost Tunnel
+
+Ghost Tunnel is the production-facing Localghost entrypoint for apps that want a stable wildcard route on top of their existing Vite product:
+
+```txt
+<route>-<project>-<owner>.ghost.<your-domain>
+```
+
+For Social Workouts, the default namespace is:
+
+```txt
+<route>-<project>-<owner>.ghost.socialworkouts.app
+```
+
+The feature is off by default. Opt in from `localghost.config.mjs`:
+
+```js
+import { defineLocalghostConfig } from "@hamedb89/localghost";
+
+export default defineLocalghostConfig({
+  ghostTunnel: {
+    domains: "socialworkouts.app",
+    mode: "manual"
+  }
+});
+```
+
+With `ghostTunnel: { domains }` in the default manual mode, route output and Vite startup output use local defaults for `route`, `project`, and `owner`, then fill the configured domain:
+
+```txt
+localghost ghost tunnel
+  mode: manual
+  expected: https://app-decision-layer-hamed.ghost.socialworkouts.app/
+```
+
+Without `domains`, the log keeps the production domain wildcarded with `*`:
+
+```txt
+localghost ghost tunnel
+  mode: manual
+  expected: https://app-decision-layer-hamed.ghost.*/
+```
+
+`manual` is the default activation mode. `ghostTunnel: "manual"` and `ghostTunnel: "public"` are shorthand modes. Use `enabled: false` to keep domains/config in the file without exposing the tunnel surface.
+
+Public mode keeps the namespace flexible unless you configure a preview. This is useful for deployed wildcard endpoints that react to whichever route arrives:
+
+```txt
+localghost ghost tunnel
+  mode: public
+  configured: https://<route>-<project>-<owner>.ghost.socialworkouts.app/
+```
+
+Use object form to override defaults or provide a concrete preview URL:
+
+```js
+export default defineLocalghostConfig({
+  ghostTunnel: {
+    domains: "socialworkouts.app",
+    preview: {
+      route: "plan",
+      project: "summer-base",
+      owner: "hamed"
+    }
+  }
+});
+```
+
+## Flow
+
+1. Add `ghostTunnel: { domains: "your-domain.com" }`, `ghostTunnel: "manual"`, or `ghostTunnel.preview` to `localghost.config.mjs`.
+2. Point the wildcard DNS record for `*.ghost.<your-domain>` at the deployed app.
+3. Route `*.ghost.<your-domain>` to the same production app that serves the Vite build.
+4. In production request handling, read the Localghost project config without resolving local `.localghost` setup.
+5. Construct tunnel URLs from `route`, `project`, and `owner`.
+6. Validate the incoming request host, protocol, and auth before serving the tunnel surface.
+
+## Vercel DNS
+
+For Vercel, add the Ghost Tunnel wildcard domain to the project first:
+
+```txt
+*.ghost.decisionlayer.tech
+```
+
+Then create the DNS record that points that wildcard at the same Vercel project. In Vercel-managed DNS, the record name is relative to the zone:
+
+```txt
+Name:  *.ghost
+Type:  ALIAS
+Value: <the Vercel DNS target shown for the project>
+TTL:   60
+```
+
+For example, if Vercel shows `cname.vercel-dns-016.com` as the project target, use the fully-qualified value with the trailing dot when the DNS form requires it:
+
+```txt
+Name:  *.ghost
+Type:  ALIAS
+Value: cname.vercel-dns-016.com.
+TTL:   60
+```
+
+When DNS is managed somewhere else, use the provider's wildcard subdomain shape:
+
+```txt
+Name:  *.ghost
+Type:  CNAME
+Value: cname.vercel-dns-016.com.
+```
+
+Do not use only `*` for Ghost Tunnel. A record named `*` covers `anything.decisionlayer.tech`, but Ghost Tunnel URLs look like `decisionlayer-decision-layer-hamed.ghost.decisionlayer.tech`, so the wildcard must live under `ghost`.
+
+```ts
+import {
+  assertSecureGhostTunnelRequest,
+  constructGhostTunnelUrl,
+  readLocalghostProjectConfig
+} from "@hamedb89/localghost";
+
+const { config } = await readLocalghostProjectConfig();
+
+const url = constructGhostTunnelUrl({
+  domain: "socialworkouts.app",
+  route: "plan",
+  project: "summer-base",
+  owner: "hamed",
+  ghostTunnel: config.ghostTunnel
+});
+
+const route = assertSecureGhostTunnelRequest({
+  host: request.headers.get("host") ?? "",
+  domain: "socialworkouts.app",
+  protocol: request.url.startsWith("https:") ? "https" : "http",
+  authenticated: Boolean(session),
+  ghostTunnel: config.ghostTunnel
+});
+
+// url is https://plan-summer-base-hamed.ghost.socialworkouts.app/
+// route.namespace is { route: "plan", project: "summer-base", owner: "hamed" }.
+```
+
+When `ghostTunnel.preview` is configured, Localghost logs the concrete preview URL in route output and Vite startup output:
+
+```txt
+localghost ghost tunnel
+  mode: manual
+  expected: https://plan-summer-base-hamed.ghost.socialworkouts.app/
+```
+
+In an interactive Vite terminal, press `g` to show the Ghost Tunnel configuration and open a numbered concrete URL. Wildcard `*` URLs are shown for observability, but the menu only opens configured concrete domains.
+
+When the app is behind a trusted deployment proxy, derive `protocol` from the platform's trusted request metadata. Do not trust arbitrary forwarded headers unless the platform has already normalized them.
+
+## Namespace DSL
+
+The default namespace tags are `route`, `project`, and `owner`, joined with `-`. The `project` tag is the default spread tag, so project slugs may contain hyphens:
+
+```js
+export default defineLocalghostConfig({
+  ghostTunnel: {
+    domains: "socialworkouts.app"
+  }
+});
+```
+
+That is equivalent to:
+
+```js
+export default defineLocalghostConfig({
+  ghostTunnel: {
+    namespace: {
+      tags: ["route", "project", "owner"],
+      spreadTag: "project"
+    }
+  }
+});
+```
+
+Apps can change the tag order, spread tag, or choose different tag names:
+
+```js
+export default defineLocalghostConfig({
+  ghostTunnel: {
+    namespace: {
+      tags: ["owner", "project", "route"],
+      spreadTag: "project"
+    }
+  }
+});
+```
+
+For custom tags, pass extra values to the constructor:
+
+```ts
+constructGhostTunnelUrl({
+  domain: "socialworkouts.app",
+  route: "plan",
+  project: "summer-base",
+  owner: "hamed",
+  values: { environment: "preview" },
+  ghostTunnel: {
+    namespace: ["environment", "route", "project", "owner"]
+  }
+});
+```
+
+## Guardrails
+
+- `ghostTunnel` is opt-in and resolves to disabled unless the project config enables it.
+- The default production entry host is `ghost.<your-domain>`, with a wildcard of `*.ghost.<your-domain>`.
+- The default wildcard label must be `route-project-owner`, such as `plan-summer-base-hamed.ghost.socialworkouts.app`.
+- The configured spread tag may contain the namespace separator. By default, that is `project`.
+- Other namespace values cannot include the namespace separator, because parsing must be reversible.
+- Host labels must be DNS-safe lowercase ASCII labels after normalization.
+- HTTPS is required by default. Set `ghostTunnel: { requireHttps: false }` only for controlled non-production testing.
+- Auth is required by default. `assertSecureGhostTunnelRequest` rejects the request unless the app passes `authenticated: true`.
+- Local Caddy and `/etc/hosts` setup do not manage Ghost Tunnel. They stay local-development-only.
+
+## Relay Security
+
+Localghost relay is private by default. Public requests can select a Ghost Tunnel route, but they must never select the local target URL, hostname, IP, or port. There must be no `/proxy?url=...` style endpoint.
+
+Route registration goes through an authenticated local agent:
+
+```ts
+import {
+  createRelayRouteRegistration,
+  signRelayRouteClaim
+} from "@hamedb89/localghost";
+
+const claim = signRelayRouteClaim({
+  host: "plan-summer-base-hamed.ghost.socialworkouts.app",
+  scope: "socialworkouts:preview",
+  agentId: "local-agent-1",
+  expiresAt: new Date(Date.now() + 10 * 60 * 1000).toISOString()
+}, signingSecret);
+
+const route = createRelayRouteRegistration({
+  authorizationHeader: request.headers.get("authorization"),
+  agentToken,
+  claimToken: claim.token,
+  signingSecret,
+  expectedScope: "socialworkouts:preview",
+  target: { host: "127.0.0.1", port: 5173 },
+  passwordProtected: true
+});
+```
+
+The relay helpers enforce these rules:
+
+- Route registration requires a matching `Bearer <agentToken>`.
+- Route claims are exact hostnames, signed, scoped, and expiring.
+- Wildcard route claims are rejected.
+- Targets must be explicit `{ host, port, protocol }` objects, never arbitrary URL strings.
+- Default target hosts are only `localhost`, `127.0.0.1`, and `::1`.
+- Blocked ports are `22`, `2375`, `2376`, `5432`, `6379`, `9200`, `9229`, and `27017`.
+- LAN/private-network targets require explicit target-policy opt-in and explicit allowed hosts.
+- Private previews require password or app auth unless `publicMode: true` is explicitly set.
+- `isRelayRouteActive(route, { agentConnected })` expires routes when the local agent disconnects or the claim expires.
+- Default limits cover request body size, response size, timeout, concurrency, per-route rate, and per-IP rate.
+- `stripRelayForwardHeaders()` removes hop-by-hop and `x-localghost-*` internal headers before forwarding.
+- `redactRelayHeaders()` and `redactRelayLogUrl()` redact `Authorization`, `Cookie`, `Set-Cookie`, and token-like query params from logs.
+- `renderRelayOfflineResponse()` returns a safe offline page with no secrets or stack traces.
+- Vite integration continues to generate explicit `allowedHosts`; it never sets `allowedHosts: true`.
+
+Run the guardrail tests locally:
+
+```sh
+npm test
+npm run test:cli
+npm run test:coverage
+```
+
+`npm test` checks the built package surface. `npm run test:cli` runs the local CLI smoke checks. `npm run test:coverage` imports the source modules and enforces coverage thresholds for `src/relay.ts` and `src/tunnel.ts`.
+
+## Custom Subdomain
+
+Use a custom entry label only when the production route truly needs it:
+
+```js
+export default defineLocalghostConfig({
+  ghostTunnel: {
+    subdomain: "preview"
+  }
+});
+```
+
+That changes the wildcard to:
+
+```txt
+<route>-<project>-<owner>.preview.example.app
+```

package/docs/github.md

@@ -4,11 +4,11 @@ Use this copy for the GitHub repo About box, topics, and social cards. Keep it s
 
 ## Repository Description
 
-Friendly local hostnames for app repos. A tiny CLI for `.localghost` configs, `/etc/hosts` blocks, Caddy reverse proxies, and Vite `allowedHosts`.
+Friendly local hostnames for app repos. Install the dev dependency, run `yarn dev`, and get clean `.localhost` URLs with Caddy and Vite-safe hosts.
 
 Shorter alternative:
 
-Friendly local hostnames for app repos, powered by `.localghost`, Caddy, `/etc/hosts`, and Vite.
+Friendly local hostnames for app repos. `yarn add -D`, `yarn dev`, ready.
 
 ## Topics
 
@@ -62,7 +62,7 @@ After creating `hamedb89/localghost`, this sets the public repo metadata:
 
 ```sh
 gh repo edit hamedb89/localghost \
-  --description "Friendly local hostnames for app repos. A tiny CLI for .localghost configs, /etc/hosts blocks, Caddy reverse proxies, and Vite allowedHosts." \
+  --description "Friendly local hostnames for app repos. Install the dev dependency, run yarn dev, and get clean .localhost URLs with Caddy and Vite-safe hosts." \
   --homepage "https://hamedb89.github.io/localghost/" \
   --add-topic localhost \
   --add-topic local-development \
@@ -78,13 +78,13 @@ gh repo edit hamedb89/localghost \
 
 ## README Opening Shape
 
-The first visible paragraph should say what it is, who it is for, and what tools it touches:
+The first visible paragraph should make the entrypoint feel obvious before it gets into configuration:
 
 ```txt
-Localghost is a tiny Node.js CLI for local domains in app repos. It gives each project one small contract for `.localhost` hostnames, Caddy reverse proxies, Vite `allowedHosts`, and the system hosts file.
+Localghost is a tiny Node.js CLI for friendly local domains in app repos. Add it as a dev dependency, run `yarn dev`, and use `http://app.localhost/` instead of remembering which localhost port belongs to which process.
 ```
 
-That phrasing helps GitHub search and npm search without making the README feel like SEO sludge.
+Then the next docs layer can explain `.localghost`, Caddy, `/etc/hosts`, Vite `allowedHosts`, and configuration options.
 
 ## GitHub Pages
 

package/docs/localghost.1.md

@@ -23,7 +23,7 @@ localghost print [--config file] [--config-pattern regex]
 
 ## Description
 
-Localghost reads `.localghost`, optionally reads `localghost.config.mjs`, writes a managed `/etc/hosts` block, records `ops/local/localghost-state.json`, generates `ops/local/Caddyfile`, and runs a Caddy local proxy. HTTP is the default; local HTTPS is explicit with `--https`, `--ssl`, or `https: true` in `localghost.config.mjs`. It is intentionally small and explicit: no hidden installs, no full hosts-file rewrites, no surprise browser tabs, and no broad Vite `allowedHosts: true` shortcut.
+Localghost reads `.localghost`, optionally reads `localghost.config.mjs`, writes a managed `/etc/hosts` block, records `ops/local/localghost-state.json`, generates `ops/local/Caddyfile`, and runs a Caddy local proxy. The project name is derived from `package.json`, port `5173` is the fallback, HTTP is the default, dynamic ports are on by default, and local HTTPS is explicit with `--https`, `--ssl`, or `https: true` in `localghost.config.mjs`. It is intentionally small and explicit: no hidden installs, no full hosts-file rewrites, no surprise browser tabs, and no broad Vite `allowedHosts: true` shortcut.
 
 Localghost checks npm for newer releases after successful commands. The check is best-effort, cached for 24 hours, and can be disabled with `LOCALGHOST_NO_UPDATE_CHECK=1` or `--no-update-check`.
 
@@ -143,12 +143,18 @@ Resolves one Localghost context, ensures setup is ready, writes the runtime Cadd
 ```sh
 localghost run -- vite
 localghost run --trust -- vite
-localghost run --dynamic-port -- turbo dev
+localghost run --dynamic-port=no -- vite
 ```
 
-Pass `--dynamic-port` or `--dynamic-port=yes` to start at the configured port and walk upward until `127.0.0.1:<port>` is free. Pass `--setup` to explicitly allow setup when the hosts block is missing or stale.
+By default, Localghost starts at the configured port and walks upward until `127.0.0.1:<port>` is free. Pass `--dynamic-port=no` when you want strict fixed-port behavior. Pass `--setup` to explicitly allow setup when the hosts block is missing or stale.
 
-When `localghost.config.mjs` exists, `run`, `dev`, `setup`, `status`, `routes`, and the Vite plugin use it as the shared context. This keeps `https`, `dynamicPort`, `project`, and `wwwAlias` decisions consistent.
+When `localghost.config.mjs` exists, `run`, `dev`, `setup`, `status`, `routes`, and the Vite plugin use it as an override layer. Most repos can skip it; add it only for decisions like `https: true`, `dynamicPort: false`, `wwwAlias: false`, custom ports, explicit project names, or the production `ghostTunnel` opt-in.
+
+`ghostTunnel` does not change local Caddy or `/etc/hosts` setup. It marks `<route>-<project>-<owner>.ghost.<domain>` as a production app entrypoint. Use `ghostTunnel: { domains: "example.com", mode: "manual" }` when the production base domain is known, or omit `domains` to keep logs wildcarded as `https://<route>-<project>-<owner>.ghost.*/`. Production code can call `readLocalghostProjectConfig()`, `constructGhostTunnelUrl()`, and `assertSecureGhostTunnelRequest()` to read the flag, construct default tunnel URLs, validate the wildcard host shape, require HTTPS by default, and require an app-authenticated request by default.
+
+Relay helpers are private by default. Registration requires an authenticated local-agent bearer token plus an exact signed route claim. Targets must be explicit local host/port objects, dangerous ports are blocked, private/LAN targets require explicit opt-in, internal and hop-by-hop headers are stripped, sensitive logs are redacted, and offline agents get a safe 503 page.
+
+When `ghostTunnel` is configured, route output and Vite startup logs print the production URL shape. Manual mode can fill local defaults for `route`, `project`, and `owner`; public mode leaves those slots as `<route>`, `<project>`, and `<owner>` unless `ghostTunnel.preview` pins a concrete URL. Add `ghostTunnel.domains` to fill one or more production base domains. When `ghostTunnel.preview` is configured with `route`, `project`, and `owner`, logs print the concrete URL, inheriting `ghostTunnel.domains` unless `preview.domain` is set. In an interactive Vite terminal, press `g` to show Ghost Tunnel configuration and open a numbered concrete URL.
 
 `dev` and `run` register active sessions in a user-local activity file so `localghost ps` can show what is running across projects.
 

package/docs/macos-widget.md

@@ -1,8 +1,10 @@
 # Localghost macOS Widget
 
-The Localghost widget is a tiny native macOS menu-bar helper. It does not start or stop apps. It only shows what Localghost already knows is running from `localghost ps --json`.
+The Localghost widget is a tiny native macOS helper. It does not start or stop apps. It reads Localghost's shared activity file directly and shows the known setup/running instances.
 
-The menu-bar title is `LG n`, where `n` is the number of active Localghost-managed sessions. The menu lists each project, wrapper PID, working directory, route, target port, and whether the upstream port is listening.
+The menu-bar title is `LG n`, where `n` is the number of known Localghost setups across the machine. The menu lists each project, working directory, route, target port, and whether the upstream port is listening. One widget tracks all setup instances; you do not run one widget per project. Running/listening routes use the green status dot, while configured but idle routes stay visible without the green state.
+
+The app also opens a small floating desktop widget using the visual direction from `Resources/localghost-widget-ui-reference.png`: dark rounded panel, Localghost title, online count, route rows, ports, and an open-first-host footer. The black/white logo source at `Resources/localghost-logo-source.png` is bundled and processed at runtime into the app image, template menu-bar icon, and white panel logo.
 
 ## Build
 
@@ -19,6 +21,31 @@ The app is written to:
 dist/LocalghostWidget.app
 ```
 
+The bundle includes:
+
+```txt
+Contents/Resources/localghost-logo-source.png
+Contents/Resources/localghost-widget-ui-reference.png
+```
+
+## Targets
+
+The macOS widget code is split into three slices:
+
+```txt
+apps/macos-widget/LocalghostWidget.swift
+apps/macos-widget/Shared/LocalghostWidgetSnapshot.swift
+apps/macos-widget/WidgetExtension/LocalghostDesktopWidget.swift
+apps/macos-widget/project.yml
+```
+
+- `LocalghostWidget.swift`: menu-bar helper and floating glass desktop panel.
+- `Shared/LocalghostWidgetSnapshot.swift`: Codable snapshot contract shared by the helper app and WidgetKit extension.
+- `WidgetExtension/LocalghostDesktopWidget.swift`: WidgetKit extension source for a real macOS desktop widget.
+- `project.yml`: XcodeGen target definition for the containing app and the WidgetKit extension.
+
+The helper app reads Localghost's live activity file and writes a smaller snapshot to the shared widget store. The WidgetKit target reads that snapshot because system widgets run in an extension context and should not depend on shell commands or arbitrary home-directory paths.
+
 ## Run
 
 If `localghost` is installed on your shell path, launch the app bundle normally.
@@ -29,18 +56,53 @@ For source development, point the widget at the repo build:
 LOCALGHOST_CLI="$PWD/dist/cli.js" dist/LocalghostWidget.app/Contents/MacOS/LocalghostWidget
 ```
 
-## Data Source
+## Desktop Widget Model
+
+This helper behaves like a desktop widget: it is a small glass panel that can sit on the desktop and is shown or hidden from the menu-bar icon. Install or run it like a normal macOS app, then use the Localghost icon in the top bar to show or hide the panel.
+
+The separate WidgetKit target is the source needed for a system desktop widget. To make it addable from macOS "Edit Widgets":
 
-The widget polls:
+1. Create or open an Xcode macOS app project for `LocalghostWidget`.
+2. Add `LocalghostWidget.swift`, `Shared/LocalghostWidgetSnapshot.swift`, and the resources to the app target.
+3. Add a Widget Extension target named `LocalghostDesktopWidgetExtension`.
+4. Add `WidgetExtension/LocalghostDesktopWidget.swift` and `Shared/LocalghostWidgetSnapshot.swift` to the extension target.
+5. Enable the same App Group on both targets: `group.app.localghost`.
+6. Sign and run/open the containing app once.
+7. Control-click the desktop, choose `Edit Widgets`, search for `Localghost`, and add the widget.
+
+The raw `npm run macos:widget:build` script builds only the standalone menu-bar helper. WidgetKit discovery requires the Xcode app + extension bundle/signing flow above.
+
+If XcodeGen is installed, generate the Xcode project with:
 
 ```sh
-localghost --no-update-check ps --json
+cd apps/macos-widget
+xcodegen generate
+open LocalghostWidget.xcodeproj
 ```
 
-That command reads the user-local activity file, prunes stale records, and probes each upstream port. The activity file defaults to:
+Then set your development team and App Group identifier before building/running the app from Xcode.
+
+## Data Source
+
+The helper reads:
 
 ```txt
 ~/.local/state/localghost/activity.json
 ```
 
+The helper writes the WidgetKit snapshot to the App Group container when available:
+
+```txt
+group.app.localghost/LocalghostWidgetSnapshot.json
+```
+
+The CLI can inspect the same state with:
+
+```sh
+localghost ps
+localghost ps --json
+```
+
+The activity file stores setup records plus active run records. `localghost setup` registers configured projects in that shared file. `localghost dev`, `localghost run`, and the Vite plugin overlay active process data on top. `localghost reset` and `localghost teardown` remove the setup from the shared file.
+
 Set `LOCALGHOST_ACTIVITY_PATH` when you want the CLI and widget to share a custom activity file during tests.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hamedb89/localghost",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Friendly local hostnames for app repos with .localghost, Caddy, /etc/hosts, and Vite.",
   "type": "module",
   "bin": {
@@ -44,12 +44,16 @@
     "build": "tsup src/index.ts src/vite.ts src/cli.ts --format esm --dts",
     "macos:widget:build": "bash apps/macos-widget/build.sh",
     "dev": "tsx src/cli.ts",
+    "test": "npm run build && node --test tests/*.test.mjs",
+    "test:coverage": "npm run build && LOCALGHOST_TEST_SOURCE=1 node --import tsx --test --experimental-test-coverage --test-coverage-include=src/relay.ts --test-coverage-include=src/tunnel.ts --test-coverage-lines=90 --test-coverage-branches=75 --test-coverage-functions=100 tests/*.test.mjs",
+    "test:cli": "npm run build && node --test tests/cli.test.mjs",
     "typecheck": "tsc --noEmit",
     "prepack": "npm run build",
     "prepublishOnly": "npm run release:check",
     "pack:dry": "npm pack --dry-run",
-    "release:check": "npm run version:check && npm run typecheck && npm run build && npm run site:build && npm pack --dry-run",
+    "release:check": "npm run version:check && npm run typecheck && npm test && npm run site:build && npm pack --dry-run",
     "site:build": "node scripts/build-site.mjs",
+    "site:serve": "node scripts/serve-site.mjs",
     "sync:version": "node scripts/sync-readme-version.mjs",
     "version:check": "node scripts/sync-readme-version.mjs --check",
     "version": "npm run sync:version && git add README.md src/update-check.ts",

package/dist/config-Cde1Bich.d.ts

@@ -1,31 +0,0 @@
-type DevHostEntry = {
-    host: string;
-    port: number;
-    target: string;
-};
-declare function parseDevHosts(input: string, fileName?: string): DevHostEntry[];
-declare function findLocalMdnsHosts(entries: DevHostEntry[]): string[];
-
-declare const LOCALGHOST_CONFIG_FILE = ".localghost";
-type ConfigPattern = string | RegExp;
-type ReadDevHostsOptions = {
-    cwd?: string;
-    fileName?: string;
-    configFiles?: string[];
-    configPattern?: ConfigPattern;
-};
-type ResolvedDevHostsPath = {
-    path: string;
-    fileName: string;
-    exists: boolean;
-    searchedFiles: string[];
-    configPattern?: ConfigPattern;
-};
-declare function getConfigFileCandidates(options?: ReadDevHostsOptions): string[];
-declare function resolveDevHostsPath(options?: ReadDevHostsOptions): ResolvedDevHostsPath;
-declare function getDevHostsPath(options?: ReadDevHostsOptions): string;
-declare function readDevHosts(options?: ReadDevHostsOptions | string): DevHostEntry[];
-declare function getProjectName(cwd?: string): string;
-declare function sanitizeProjectName(value: string): string;
-
-export { type ConfigPattern as C, type DevHostEntry as D, LOCALGHOST_CONFIG_FILE as L, type ReadDevHostsOptions as R, type ResolvedDevHostsPath as a, getDevHostsPath as b, getProjectName as c, resolveDevHostsPath as d, findLocalMdnsHosts as f, getConfigFileCandidates as g, parseDevHosts as p, readDevHosts as r, sanitizeProjectName as s };