@hamedb89/localghost 0.1.6 → 0.1.8

package/README.md

@@ -9,7 +9,7 @@ Buh. Friendly local hostnames for app repos.
 [![CI](https://github.com/hamedb89/localghost/actions/workflows/ci.yml/badge.svg)](https://github.com/hamedb89/localghost/actions/workflows/ci.yml)
 [![GitHub Pages](https://github.com/hamedb89/localghost/actions/workflows/pages.yml/badge.svg)](https://github.com/hamedb89/localghost/actions/workflows/pages.yml)
 [![Publish npm](https://github.com/hamedb89/localghost/actions/workflows/publish-npm.yml/badge.svg)](https://github.com/hamedb89/localghost/actions/workflows/publish-npm.yml)
-[![npm version](https://img.shields.io/badge/npm-v0.1.6-CB3837?logo=npm)](https://www.npmjs.com/package/@hamedb89/localghost)
+[![npm version](https://img.shields.io/badge/npm-v0.1.8-CB3837?logo=npm)](https://www.npmjs.com/package/@hamedb89/localghost)
 
 Localghost is a tiny Node.js CLI for friendly 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, so developers can open `http://app.localhost/` instead of remembering which localhost port belongs to which process.
 
@@ -102,6 +102,12 @@ Use HTTPS only when you explicitly want Caddy local certificates:
 yarn localghost:proxy:https
 ```
 
+Trust Caddy's local HTTPS CA when you want browsers to stop showing local certificate warnings:
+
+```sh
+yarn localghost:trust
+```
+
 Reset generated setup without deleting `.localghost`:
 
 ```sh
@@ -146,6 +152,7 @@ The Vite plugin accepts the same shape through `fileName`, `configFiles`, or `co
     "localghost:proxy:https": "localghost dev --https",
     "localghost:run": "localghost run --",
     "localghost:ready": "localghost status --ready",
+    "localghost:trust": "localghost trust",
     "localghost:ps": "localghost ps",
     "localghost:print": "localghost print",
     "localghost:routes": "localghost routes",
@@ -165,7 +172,7 @@ A full app might compose them with its own servers:
 ```json
 {
   "scripts": {
-    "dev": "localghost run -- vite",
+    "dev": "localghost run -- yarn dev:raw",
     "dev:dynamic": "localghost run --dynamic-port -- vite",
     "dev:raw": "vite"
   }
@@ -177,7 +184,7 @@ In Turborepo, let Localghost wrap the dev runner and keep dev uncached:
 ```json
 {
   "scripts": {
-    "dev": "localghost run --dynamic-port -- turbo dev",
+    "dev": "localghost run --dynamic-port -- yarn dev:raw",
     "dev:raw": "turbo dev"
   }
 }
@@ -193,7 +200,33 @@ Then keep persistent dev tasks uncached:
 }
 ```
 
-`localghost run` resolves one shared Localghost context, starts Caddy, passes the selected port to the child command through `LOCALGHOST_PORT` and `VITE_PORT`, and stops Caddy when the child exits. With `--dynamic-port`, Localghost starts at the configured port, checks `127.0.0.1:<port>`, and walks upward until it finds a free port.
+`localghost run` resolves one shared Localghost context, starts Caddy, handles the optional HTTPS trust prompt, then starts the child command. That keeps Localghost setup/proxy output before Vite's ready log. It passes the selected port to the child command through `LOCALGHOST_PORT` and `VITE_PORT`, and stops Caddy when the child exits. With `--dynamic-port`, Localghost starts at the configured port, checks `127.0.0.1:<port>`, and walks upward until it finds a free port.
+
+When settings need to be shared by the CLI wrapper and the Vite plugin, put them in `localghost.config.mjs`:
+
+```js
+import { defineLocalghostConfig } from "@hamedb89/localghost";
+
+export default defineLocalghostConfig({
+  project: "app",
+  port: 5173,
+  https: true,
+  dynamicPort: true
+});
+```
+
+Then the daily script can stay small:
+
+```json
+{
+  "scripts": {
+    "dev": "localghost run -- yarn dev:raw",
+    "dev:raw": "vite"
+  }
+}
+```
+
+`www.` aliases are enabled by default. A `.localghost` entry like `app.localhost 5173` also sets up `www.app.localhost` unless `wwwAlias: false` is set in `localghost.config.mjs`.
 
 `localghost dev` and `localghost run` also register their active sessions in a user-local activity file. Use `localghost ps` to see the Localghost apps currently running on the machine:
 
@@ -209,6 +242,19 @@ app  run: vite
 
 Pass `--json` when another helper, such as a menu bar app, needs to poll the same state.
 
+## macOS Widget
+
+Localghost includes a tiny native macOS menu-bar widget in `apps/macos-widget`. It shows `LG n` in the top bar, where `n` is the number of active Localghost-managed apps, and its menu lists each project, route, target port, and listening state.
+
+Build it from source:
+
+```sh
+npm run build
+npm run macos:widget:build
+```
+
+The app bundle is written to `dist/LocalghostWidget.app`. See [docs/macos-widget.md](./docs/macos-widget.md) for local development notes.
+
 ## Vite
 
 ```ts
@@ -219,14 +265,13 @@ export default defineConfig({
   plugins: [
     localGhostPlugin({
       port: 5173,
-      dynamicPort: true,
       configFiles: [".localghost.private", ".localghost"]
     })
   ]
 });
 ```
 
-The plugin binds Vite to `127.0.0.1` by default, prints the selected Localghost domain, generates an explicit `server.allowedHosts` list from the selected config file, and does not set `allowedHosts: true`. It runs only during local `vite serve`; production/build mode no-ops. When `dynamicPort` is enabled, the plugin uses the configured port when available and otherwise moves to the next free port before Vite starts.
+The plugin binds Vite to `127.0.0.1` by default, prints the selected Localghost domain, generates an explicit `server.allowedHosts` list from the selected config file, and does not set `allowedHosts: true`. It runs only during local `vite serve`; production/build mode no-ops. When `dynamicPort` is enabled in plugin options or `localghost.config.mjs`, the plugin uses the configured port when available and otherwise moves to the next free port before Vite starts.
 
 If `.localghost` is missing and Vite is running in an interactive terminal, the plugin asks whether to create one, prompts for the primary domain and optional extra domains, and then asks whether to run setup. Before touching `/etc/hosts`, it explains why macOS may ask for your password and confirms that only Localghost's managed block is changed.
 
@@ -253,6 +298,7 @@ localghost setup
 localghost setup --project app
 localghost setup --config .localghost.preview
 localghost setup --https
+localghost trust
 localghost status
 localghost status --ready
 localghost ps
@@ -263,6 +309,7 @@ localghost teardown --remove-caddyfile
 localghost update
 localghost --no-update-check doctor
 localghost run -- vite
+localghost run --trust -- vite
 localghost run --dynamic-port -- turbo dev
 localghost dev --config-pattern '^\.localghost\.'
 localghost dev --https
@@ -273,6 +320,8 @@ Localghost checks npm for newer releases after successful commands. The check ha
 
 `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, `localghost dev` and `localghost run` ask once whether to trust Caddy's local HTTPS CA. If you accept, macOS may ask for your password so Caddy can add its local CA to Keychain. Localghost records the result in `ops/local/localghost-state.json`; use `localghost trust` or `localghost run --trust -- ...` when you want to rerun the trust step intentionally.
+
 `setup` writes only a managed block in the system hosts file:
 
 ```txt

package/apps/macos-widget/LocalghostWidget.swift

@@ -0,0 +1,218 @@
+import AppKit
+import Foundation
+
+struct LocalghostPsResponse: Decodable {
+    let activityPath: String?
+    let runs: [LocalghostRun]
+}
+
+struct LocalghostRun: Decodable {
+    let mode: String
+    let pid: Int
+    let cwd: String
+    let projectName: String
+    let startedAt: String
+    let childCommand: [String]?
+    let routes: [LocalghostRoute]
+}
+
+struct LocalghostRoute: Decodable {
+    let host: String
+    let port: Int
+    let target: String
+    let listening: Bool
+}
+
+final class LocalghostWidgetApp: NSObject, NSApplicationDelegate {
+    private let statusItem = NSStatusBar.system.statusItem(withLength: NSStatusItem.variableLength)
+    private var timer: Timer?
+    private var latestRuns: [LocalghostRun] = []
+    private var latestError: String?
+
+    func applicationDidFinishLaunching(_ notification: Notification) {
+        NSApp.setActivationPolicy(.accessory)
+        statusItem.button?.title = "LG ..."
+        rebuildMenu()
+        refresh()
+        timer = Timer.scheduledTimer(withTimeInterval: 5, repeats: true) { [weak self] _ in
+            self?.refresh()
+        }
+    }
+
+    private func refresh() {
+        DispatchQueue.global(qos: .utility).async { [weak self] in
+            let result = Self.loadRuns()
+            DispatchQueue.main.async {
+                switch result {
+                case .success(let runs):
+                    self?.latestRuns = runs
+                    self?.latestError = nil
+                case .failure(let error):
+                    self?.latestRuns = []
+                    self?.latestError = error.localizedDescription
+                }
+
+                self?.updateStatusTitle()
+                self?.rebuildMenu()
+            }
+        }
+    }
+
+    private func updateStatusTitle() {
+        if latestError != nil {
+            statusItem.button?.title = "LG ?"
+            return
+        }
+
+        statusItem.button?.title = "LG \(latestRuns.count)"
+    }
+
+    private func rebuildMenu() {
+        let menu = NSMenu()
+
+        if let latestError {
+            let item = NSMenuItem(title: "Localghost unavailable", action: nil, keyEquivalent: "")
+            item.isEnabled = false
+            menu.addItem(item)
+
+            let detail = NSMenuItem(title: latestError, action: nil, keyEquivalent: "")
+            detail.isEnabled = false
+            menu.addItem(detail)
+        } else if latestRuns.isEmpty {
+            let item = NSMenuItem(title: "No Localghost apps running", action: nil, keyEquivalent: "")
+            item.isEnabled = false
+            menu.addItem(item)
+        } else {
+            let title = latestRuns.count == 1 ? "1 Localghost app running" : "\(latestRuns.count) Localghost apps running"
+            let item = NSMenuItem(title: title, action: nil, keyEquivalent: "")
+            item.isEnabled = false
+            menu.addItem(item)
+
+            menu.addItem(.separator())
+
+            for run in latestRuns {
+                addRun(run, to: menu)
+                menu.addItem(.separator())
+            }
+        }
+
+        let refreshItem = NSMenuItem(title: "Refresh", action: #selector(refreshFromMenu), keyEquivalent: "r")
+        refreshItem.target = self
+        menu.addItem(refreshItem)
+
+        let quitItem = NSMenuItem(title: "Quit Localghost Widget", action: #selector(quit), keyEquivalent: "q")
+        quitItem.target = self
+        menu.addItem(quitItem)
+
+        statusItem.menu = menu
+    }
+
+    private func addRun(_ run: LocalghostRun, to menu: NSMenu) {
+        let command = run.childCommand?.joined(separator: " ")
+        let mode = command.map { "\(run.mode): \($0)" } ?? run.mode
+        let title = "\(run.projectName)  \(mode)"
+        let projectItem = NSMenuItem(title: title, action: nil, keyEquivalent: "")
+        projectItem.isEnabled = false
+        menu.addItem(projectItem)
+
+        let cwdItem = NSMenuItem(title: "  \(run.cwd)", action: nil, keyEquivalent: "")
+        cwdItem.isEnabled = false
+        menu.addItem(cwdItem)
+
+        let pidItem = NSMenuItem(title: "  pid \(run.pid)", action: nil, keyEquivalent: "")
+        pidItem.isEnabled = false
+        menu.addItem(pidItem)
+
+        for route in run.routes {
+            let state = route.listening ? "listening" : "not listening"
+            let routeItem = NSMenuItem(title: "  \(route.host) -> \(route.target) (\(state))", action: nil, keyEquivalent: "")
+            routeItem.isEnabled = false
+            menu.addItem(routeItem)
+        }
+    }
+
+    @objc private func refreshFromMenu() {
+        refresh()
+    }
+
+    @objc private func quit() {
+        NSApp.terminate(nil)
+    }
+
+    private static func loadRuns() -> Result<[LocalghostRun], Error> {
+        do {
+            let output = try runLocalghostPs()
+            let response = try JSONDecoder().decode(LocalghostPsResponse.self, from: output)
+            return .success(response.runs)
+        } catch {
+            return .failure(error)
+        }
+    }
+
+    private static func runLocalghostPs() throws -> Data {
+        let task = Process()
+        task.executableURL = URL(fileURLWithPath: "/usr/bin/env")
+        task.arguments = localghostArguments()
+        task.environment = [
+            "PATH": pathValue()
+        ]
+
+        let stdout = Pipe()
+        let stderr = Pipe()
+        task.standardOutput = stdout
+        task.standardError = stderr
+
+        try task.run()
+        task.waitUntilExit()
+
+        let output = stdout.fileHandleForReading.readDataToEndOfFile()
+        if task.terminationStatus == 0 {
+            return output
+        }
+
+        let errorData = stderr.fileHandleForReading.readDataToEndOfFile()
+        let message = String(data: errorData, encoding: .utf8)?.trimmingCharacters(in: .whitespacesAndNewlines)
+        throw LocalghostWidgetError.commandFailed(message?.isEmpty == false ? message! : "localghost ps failed")
+    }
+
+    private static func localghostCommand() -> String {
+        ProcessInfo.processInfo.environment["LOCALGHOST_CLI"] ?? "localghost"
+    }
+
+    private static func localghostArguments() -> [String] {
+        let command = localghostCommand()
+        if command.hasSuffix(".js") {
+            return ["node", command, "--no-update-check", "ps", "--json"]
+        }
+
+        return [command, "--no-update-check", "ps", "--json"]
+    }
+
+    private static func pathValue() -> String {
+        let existing = ProcessInfo.processInfo.environment["PATH"] ?? ""
+        let defaults = "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin"
+        return existing.isEmpty ? defaults : "\(existing):\(defaults)"
+    }
+}
+
+enum LocalghostWidgetError: LocalizedError {
+    case commandFailed(String)
+
+    var errorDescription: String? {
+        switch self {
+        case .commandFailed(let message):
+            return message
+        }
+    }
+}
+
+@main
+struct LocalghostWidgetMain {
+    private static let delegate = LocalghostWidgetApp()
+
+    static func main() {
+        let app = NSApplication.shared
+        app.delegate = delegate
+        app.run()
+    }
+}

package/apps/macos-widget/build.sh

@@ -0,0 +1,53 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "$0")/../.." && pwd)"
+APP_DIR="$ROOT_DIR/dist/LocalghostWidget.app"
+CONTENTS_DIR="$APP_DIR/Contents"
+MACOS_DIR="$CONTENTS_DIR/MacOS"
+SOURCE_FILE="$ROOT_DIR/apps/macos-widget/LocalghostWidget.swift"
+EXECUTABLE="$MACOS_DIR/LocalghostWidget"
+MODULE_CACHE_DIR="${TMPDIR:-/tmp}/localghost-swift-module-cache"
+
+rm -rf "$APP_DIR"
+mkdir -p "$MACOS_DIR"
+mkdir -p "$MODULE_CACHE_DIR"
+
+swiftc \
+  -parse-as-library \
+  -O \
+  -module-cache-path "$MODULE_CACHE_DIR" \
+  -framework AppKit \
+  "$SOURCE_FILE" \
+  -o "$EXECUTABLE"
+
+cat > "$CONTENTS_DIR/Info.plist" <<'PLIST'
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "https://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleExecutable</key>
+  <string>LocalghostWidget</string>
+  <key>CFBundleIdentifier</key>
+  <string>app.localghost.widget</string>
+  <key>CFBundleName</key>
+  <string>Localghost Widget</string>
+  <key>CFBundleDisplayName</key>
+  <string>Localghost Widget</string>
+  <key>CFBundlePackageType</key>
+  <string>APPL</string>
+  <key>CFBundleShortVersionString</key>
+  <string>0.1.0</string>
+  <key>CFBundleVersion</key>
+  <string>1</string>
+  <key>LSMinimumSystemVersion</key>
+  <string>13.0</string>
+  <key>LSUIElement</key>
+  <true/>
+  <key>NSHighResolutionCapable</key>
+  <true/>
+</dict>
+</plist>
+PLIST
+
+echo "Built $APP_DIR"