@huynle/hub 0.8.3 → 0.8.5

package/CHANGELOG.md

@@ -1,5 +1,85 @@
 # Changelog
 
+## 0.8.5
+
+Set up Hub on a machine in one line. The console's new **Set up Hub on a machine** (avatar menu, Settings → Machines
+& devices, Watchtower) builds a `curl … | sh` (macOS, Linux) or `irm … | iex` (Windows) command that the hub serves
+with its own URL and version: it installs and checks hubctl, enrolls the machine (you approve it in the console) and
+sets it up. hubctl now runs natively on Windows x64 for the OpenCode-only profile. No migration is needed.
+
+### Machine setup
+- **The hub serves one-line install scripts**: public `GET /install.sh` (macOS, Linux: `curl -fsSL '<hub>/install.sh?…' | sh`)
+  and `GET /install.ps1` (Windows: `irm '<hub>/install.ps1?…' | iex`), rendered from fixed templates with only the
+  hub's public URL, its version and the validated choices (`profile`, `root`, `activate`; anything else answers 400
+  with the reason; never a token). They pin this hub's hubctl release; the new `HUB_RELEASE_BASE` points them
+  elsewhere (https, or http on loopback or a private-network IP), and a development version without it answers 503.
+  A plain-http hub is served only on loopback or a private-network IP (with `--allow-insecure-http`), else 400.
+  Leave both paths reachable behind an authenticating proxy, like `/.well-known/hub`.
+- **`install.ps1` installs hubctl on Windows** (x64; arm64 and 32-bit are refused with the reason): it downloads
+  `hubctl-windows-x64.exe`, checks its sha256 against `HUBCTL_SHA256SUMS` (`Get-FileHash`), then runs the same
+  `machine status` / `machine enroll` / `setup preview` / `setup apply` / `setup verify` sequence as `install.sh`
+  (session-only), and adds `%USERPROFILE%\.local\bin` to the user PATH once (`%VARS%` in it are kept). It no longer adds
+  the OpenCode plugin or writes the spoke config itself; it still never closes the PowerShell window.
+- Console: **Set up Hub on a machine**, one dialog opened from the avatar's new menu, Settings → Machines & devices
+  (**Set up a machine**, also in the settings search) and Watchtower's **Connect a machine**: pick the OS (detected),
+  the profile (OpenCode only, + launch node with its workspace folder, All harnesses; Windows: OpenCode only for
+  now) and Start services now, then copy the `curl … | sh` or `irm … | iex` one-liner built from the hub's public URL.
+
+### hubctl on Windows (x64, OpenCode only)
+- **`hubctl-windows-x64.exe`** is built, signed into the release manifest and smoke-tested on Windows. Windows paths
+  (`C:/…`) are first-class in plans and journals; discovery reads `%USERPROFILE%`, PATHEXT, `.cmd` shims and the
+  machine's `MachineGuid`. `hub` and `opencode` on PATH are `.cmd` shims, the harness's current version is a junction,
+  files in use are replaced rename-aside, and the machine credential gets an owner-only ACL. `+ launch node` and
+  `All harnesses` need user services and are refused on Windows for now. This release pins no OpenCode for Windows
+  yet: a Windows machine without OpenCode is asked to install it first.
+- **The OpenCode plugin writes `.cmd` launchers on Windows** instead of `#!/bin/sh` scripts and a symlink, and never
+  overwrites hubctl's `hub.cmd`.
+- **Rollback**: a rollback that removes the running `hubctl.exe` deletes it once it exits and lists what it undid; a
+  path in use undoes everything else, names the path and is finished by `hubctl setup recover`.
+- **Verify probes leave nothing running** (all harnesses, every OS): `opencode models --standalone`, and the probe's
+  whole process tree ends with it.
+
+### Fixes
+- `HEAD /install.sh` and `/install.ps1` answer like GET without a body.
+
+## 0.8.4
+
+A fix release. A question or permission a session is waiting on no longer disappears from the console while
+OpenCode still waits (after the session briefly left a machine's list, or after a reconnect): the hub keeps a bounded
+card for it and puts it back, and the machine re-announces what is pending after every reconnect. "Needs you" and the
+hub now agree; a terminal Herdr reports blocked with nothing pending on the hub shows as "waiting in terminal".
+No migration is needed; machines need the 0.8.4 plugin for the reconnect part.
+
+### Fixes
+- **The hub drops a question or permission whose ID is longer than any card keeps** (200 characters), so no such
+  entry is stored or alerted.
+- **A pending question or permission no longer vanishes from the console while OpenCode still waits**
+  (production 2026-11-05: a session's question card disappeared, `show` said "Nothing waiting", the session still ran
+  in the question tool). The hub kept blockers only on a session's status board, built from live events: a board
+  recreated after the session left a sessions frame for a moment started empty, and a reconnecting spoke (laptop
+  sleep, network change, a restarted OpenCode process or hub) lost every pending question with the old connection and
+  never announced it again. Now the hub puts pending questions and permissions back on recreated boards (and on
+  boards created after the question was asked), the form stays answerable, and the spoke re-announces what is pending
+  after each reconnect: what it saw asked, plus what OpenCode lists for its active sessions (pending forms and
+  permission requests from the process's own server), closing those OpenCode no longer has. A re-announced question
+  or permission is not notified twice. Tests: `test/central-registry-blockers.test.ts`, `test/e2e-lost-question.test.ts`,
+  the spoke's reconnect tests and the browser suite `web/e2e/question-survives.ts`.
+  - What the hub keeps of a pending question or permission is the bounded card (at most 20 fields, the text limits,
+    10 resources; at most 64 kB, over which descriptions and then fields are left out; IDs over 200 characters are
+    refused), at most 200 per user for each kind. A permission card's summary is now bounded too (it joined every
+    resource). Another user can no longer close a pending question or permission by its ID, nor push it out with a
+    flood of its own.
+  - The spoke re-sends what it remembers right after reconnecting, then asks OpenCode (at most 50 sessions, the ones
+    with something remembered first, 5 s at most). Closes it infers from OpenCode's lists carry `unlisted: true`: the
+    hub drops only that process's hold on the question.
+  - Mixed versions: the hub announces the new `pendingReplay` feature. To an older hub (no such feature, and no
+    dedupe of re-sent permissions) the spoke re-sends only questions, so permissions it told that hub already are
+    lost on a reconnect as before rather than notified twice; a question lost from a frame drop is still lost on an
+    older hub. An older spoke on a new hub behaves as before (lost on reconnect).
+- **"Needs you" only when there is something to answer.** A session that only Herdr calls blocked (its agent waits
+  for input, the hub has no question or permission for it) is no longer under Needs you or counted there: its row
+  shows "waiting in terminal" and it counts as working.
+
 ## 0.8.3
 
 A voice and security release. A new developer setting records voice conversations (the Concierge and any voice

package/README.md

@@ -179,6 +179,41 @@ Optional: put the voice agent on a fast model in `~/.config/hub/config.json`:
 `"voiceModel": "anthropic/claude-haiku-4-5"` (any `provider/model` you have). Subagents keep the
 session's model.
 
+## Set up a machine (one line)
+
+The hub serves an install script for its own version, so a machine needs only one command. In the console use
+**Set up Hub on a machine** (avatar menu, Settings → Machines, or Watchtower's **Connect a machine**) and copy the
+line it shows, or write it yourself:
+
+```sh
+# macOS / Linux (POSIX sh): downloads and checks hubctl, enrolls (approve the code in the console), previews, applies
+curl -fsSL 'https://hub.example.com/install.sh' | sh
+curl -fsSL 'https://hub.example.com/install.sh?profile=launch-node&root=~/projects&activate=1' | sh
+```
+
+```powershell
+# Windows x64 (PowerShell 5.1 or 7): the same steps with hubctl-windows-x64.exe; OpenCode only for now
+irm 'https://hub.example.com/install.ps1' | iex
+```
+
+Query options (each optional, at most once; anything else answers 400 with the reason):
+
+| Key | Values | Default |
+|---|---|---|
+| `profile` | `session-only` (OpenCode only), `launch-node` (+ a launch node), `full-harness` (all harnesses) | `session-only` |
+| `root` | the launch node's workspace root, only with `launch-node`: up to 200 characters of `A-Z a-z 0-9 . _ / ~ -`, starting with `/` or `~/`, no `..` or `//` | `~/projects` |
+| `activate` | `1` starts the services now (`--confirm-activation`), `0` leaves them stopped | `0` |
+
+`install.ps1` takes only `profile=session-only` and `activate=0` for now (hubctl does not install user services on
+Windows yet) and runs on x64 Windows only (no arm64 build yet). It never closes your PowerShell window: a failure is
+one red `hub setup:` line. After a successful apply it adds `%USERPROFILE%\.local\bin` to your user PATH (once; open a
+new terminal for other windows). The scripts carry
+the hub's public URL, version and the validated choices; never a token. They download hubctl from this version's
+release on [hub-releases](https://github.com/huynle/hub-releases/releases) (`v<version>`); `HUB_RELEASE_BASE` on
+the hub points them at another location (a mirror, or a development build, which otherwise answers 503). A
+plain-`http` hub is served only on loopback or a private-network IP address (the script then passes
+`--allow-insecure-http`); on a host name or a public address the routes answer 400: use https.
+
 ## Quick start (hubctl, before any harness)
 
 `hubctl` is a standalone, signed program (Bun and the CLI compiled into one file; no bun, node or harness needed)
@@ -317,8 +352,9 @@ foreground with `hub.json`; `scripts/io.github.huynle.hub.plist` is a launchd te
 **Security:** the hub can drive your OpenCode sessions, which can run tools. Every API call needs a
 paired device or a signed-in user; spokes need machine tokens; nothing trusts the client IP. For a public
 hostname, consider [sign-in with Google](#multi-user-sign-in-with-google) or an authenticating proxy in
-front of the web app, and leave `/spoke/*`, `/auth/*`, `/healthz`, `/.well-known/hub`, the manifest and
-icons reachable for spokes, sign-in, app discovery and the PWA (and `/mcp`, bearer-authenticated, if MCP clients
+front of the web app, and leave `/spoke/*`, `/auth/*`, `/healthz`, `/.well-known/hub`, `/install.sh`,
+`/install.ps1`, the manifest and icons reachable for spokes, sign-in, app discovery, [machine
+setup](#set-up-a-machine-one-line) and the PWA (and `/mcp`, bearer-authenticated, if MCP clients
 or gateways use [MCP over HTTP](#over-http-mcp)).
 
 **Behind a reverse proxy**, set a request-body limit of about 26 MiB (artifact blobs are up to 25 MiB) and keep
@@ -328,7 +364,7 @@ including `blobs/` (artifact bytes).
 
 ## Configuration
 
-- **Hub**: env vars (`HUB_HOST`, `HUB_PORT`, `HUB_PUBLIC_URL`, `HUB_STATE_DIR`, `OPENROUTER_API_KEY`, …)
+- **Hub**: env vars (`HUB_HOST`, `HUB_PORT`, `HUB_PUBLIC_URL`, `HUB_STATE_DIR`, `HUB_RELEASE_BASE`, `OPENROUTER_API_KEY`, …)
   over `~/.config/hub/hub.json` (`$HUB_CONFIG`); see [Central server](#central-server) and
   [hub.json](#hubjson). Speech providers and keys are easiest to set in the app (Settings → Speech).
 - **Plugin** (OpenCode spoke): `~/.config/hub/config.json` (`$HUB_SPOKE_CONFIG`; server, mode, machine
@@ -1218,6 +1254,7 @@ holds the startup (`bin/hub.ts` serves `web/` from disk; the compiled binaries e
 | `HUB_DATABASE_STATEMENT_TIMEOUT_MS` | `30000` | cluster mode: Postgres `statement_timeout` of the hub's pools (`0` turns it off) |
 | `HUB_TURN_TIMEOUT_MS` | `600000` | the hub waits this + 15 s so the spoke's own timeout result arrives first |
 | `HUB_VAPID_SUBJECT` | the https public URL, else `mailto:hub@localhost` | contact sent to push services |
+| `HUB_RELEASE_BASE` | `https://github.com/huynle/hub-releases/releases/download/v<version>` | where `/install.sh` and `/install.ps1` download hubctl ([Set up a machine](#set-up-a-machine-one-line)): https, or plain http on loopback or a private-network IP address; the hub refuses to start with any other value. Without it a development version (not a plain `x.y.z`) answers 503 |
 | `HUB_CSP` | `enforce` | `report-only` sends the console's Content-Security-Policy as `Content-Security-Policy-Report-Only` (violations are only logged in the browser console); see [Content-Security-Policy](#content-security-policy) |
 | `OPENROUTER_API_KEY` | | default key for the `openrouter` speech provider (never sent to other providers) |
 | `HUB_STT_MODEL`, `HUB_TTS_MODEL`, `HUB_VOICE`, `HUB_MAX_*` | see `src/central/config.ts` | speech defaults; the phone's speech settings override them |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@huynle/hub",
-  "version": "0.8.3",
+  "version": "0.8.5",
   "description": "Hub: a harness-agnostic central hub your AI agent harnesses connect to (OpenCode first). Follow, steer and stop sessions from your phone or browser, with notifications, optional hands-free Voice and a self-hostable server.",
   "license": "MIT",
   "author": "Huy Le",

package/packages/claude-code/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@huynle/hub-claude-code",
-  "version": "0.8.3",
+  "version": "0.8.5",
   "private": true,
   "description": "The Claude Code hooks spoke: per-user daemon, hook bridge, plugin dir, `hub claude` wrapper and daemon-backed MCP server (internal; shipped inside @huynle/hub, not published on its own).",
   "license": "MIT",