@hamedb89/localghost 0.1.6 → 0.1.9

package/docs/ghost-tunnel.md

@@ -0,0 +1,249 @@
+# 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 }`, 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.
+
+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.
+
+```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

@@ -10,24 +10,27 @@ localghost - friendly local hostnames for app repos
 localghost init [--write-scripts] [--config file] [--host host] [--port port]
 localghost doctor
 localghost setup [--project name] [--config file] [--config-pattern regex] [--https|--ssl]
+localghost trust [--project name] [--config file] [--config-pattern regex] [--https|--ssl]
 localghost reset [--project name]
 localghost teardown [--project name] [--remove-caddyfile]
 localghost status [--ready] [--json]
 localghost ps [--json]
 localghost update [--json]
-localghost dev [--config file] [--config-pattern regex] [--https|--ssl] [--setup]
-localghost run [--config file] [--config-pattern regex] [--https|--ssl] [--setup] [--dynamic-port] -- command
+localghost dev [--config file] [--config-pattern regex] [--https|--ssl] [--setup] [--trust]
+localghost run [--config file] [--config-pattern regex] [--https|--ssl] [--setup] [--trust] [--dynamic-port] -- command
 localghost print [--config file] [--config-pattern regex]
 ```
 
 ## Description
 
-Localghost reads `.localghost`, 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` or `--ssl`. 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`.
 
 `setup`, `dev`, and `teardown` refuse to run in production-like environments such as `NODE_ENV=production`, `VERCEL_ENV=production`, or `LOCALGHOST_ENV=production`.
 
+When HTTPS is enabled, `dev` and `run` can trust Caddy's local HTTPS CA before the child app starts. Localghost asks once in interactive terminals, records the answer in `ops/local/localghost-state.json`, and supports `--trust` or `localghost trust` when you want to rerun the trust step intentionally.
+
 ## Commands
 
 ### init
@@ -67,6 +70,14 @@ Updates the managed Localghost block in `/etc/hosts`, writes `ops/local/Caddyfil
 localghost setup --project app
 ```
 
+### trust
+
+Validates the HTTPS Caddyfile and runs `caddy trust --config <Caddyfile>` so browsers can trust Caddy's local development certificates. macOS may ask for your password to add Caddy's local CA to Keychain.
+
+```sh
+localghost trust
+```
+
 ### teardown
 
 Removes the managed Localghost block from `/etc/hosts` for the selected project and records the action in `ops/local/localghost-state.json`. It leaves `ops/local/Caddyfile` in place unless `--remove-caddyfile` is passed.
@@ -119,7 +130,7 @@ localghost routes
 
 ### dev
 
-Requires setup to be ready, writes `ops/local/Caddyfile`, validates it, and runs Caddy. Supports `--config` and `--config-pattern`. HTTP is the default. Pass `--https` or `--ssl` to run a local HTTPS proxy. Pass `--setup` to explicitly allow `dev` to run setup first when setup is missing or stale.
+Requires setup to be ready, writes `ops/local/Caddyfile`, validates it, and runs Caddy. Supports `--config` and `--config-pattern`. HTTP is the default. Pass `--https` or `--ssl` to run a local HTTPS proxy. Pass `--setup` to explicitly allow `dev` to run setup first when setup is missing or stale. Pass `--trust` to force the Caddy trust step before the proxy stays running.
 
 ```sh
 localghost dev
@@ -127,14 +138,23 @@ localghost dev
 
 ### run
 
-Resolves one Localghost context, ensures setup is ready, writes the runtime Caddyfile, starts Caddy, and runs a child dev command. The selected port is passed to the child as `LOCALGHOST_PORT` and `VITE_PORT`.
+Resolves one Localghost context, ensures setup is ready, writes the runtime Caddyfile, starts Caddy, handles the optional HTTPS trust prompt, and then runs a child dev command. The selected port is passed to the child as `LOCALGHOST_PORT` and `VITE_PORT`.
 
 ```sh
 localghost run -- vite
-localghost run --dynamic-port -- turbo dev
+localghost run --trust -- vite
+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 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 local defaults for `route`, `project`, and `owner`. Add `ghostTunnel.domains` to fill one or more production base domains. When `ghostTunnel.preview` is configured with `route`, `project`, and `owner`, they 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.
 
@@ -149,6 +169,7 @@ localghost print
 ## Files
 
 - `.localghost`: default project hostname config.
+- `localghost.config.mjs`: optional shared context for CLI and Vite settings.
 - custom config files: pass `--config <file>` or `--config-pattern <regex>`.
 - `ops/local/Caddyfile`: generated local Caddy config.
 - `ops/local/localghost-state.json`: last setup or teardown action.

package/docs/macos-widget.md

@@ -0,0 +1,108 @@
+# Localghost macOS Widget
+
+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 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
+
+Build the CLI first, then build the app bundle:
+
+```sh
+npm run build
+npm run macos:widget:build
+```
+
+The app is written to:
+
+```txt
+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.
+
+For source development, point the widget at the repo build:
+
+```sh
+LOCALGHOST_CLI="$PWD/dist/cli.js" dist/LocalghostWidget.app/Contents/MacOS/LocalghostWidget
+```
+
+## 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":
+
+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
+cd apps/macos-widget
+xcodegen generate
+open LocalghostWidget.xcodeproj
+```
+
+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.6",
+  "version": "0.1.9",
   "description": "Friendly local hostnames for app repos with .localghost, Caddy, /etc/hosts, and Vite.",
   "type": "module",
   "bin": {
@@ -17,6 +17,7 @@
     }
   },
   "files": [
+    "apps/macos-widget",
     "dist",
     "assets",
     "docs",
@@ -41,13 +42,18 @@
   "scripts": {
     "clean": "rm -rf dist",
     "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 };