@shanesaravia/hive 0.1.0 → 0.1.1

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 All notable changes to Hive will be documented in this file.
 
+## 0.1.1 — 2026-08-23
+
+- Add `hive update`, with read-only checks, interactive or unattended installation, setup refresh, and automatic restart of an active local server.
+
 ## 0.1.0 — 2026-08-23
 
 Initial public preview of Hive, a provider-neutral local mission-control interface for Claude Code, Codex, and agent fleets.
@@ -14,4 +18,5 @@ Initial public preview of Hive, a provider-neutral local mission-control interfa
 - Mission health, lifecycle, recovery, policies, budgets, templates, notifications, and searchable history
 - Repository-aware working directories, skills, MCP configuration, and Git worktrees where supported
 - Installable `hive` CLI with diagnostics, optional setup, persistent local state, and graceful lifecycle commands
+- Browser-origin enforcement protecting the loopback control API and WebSocket from foreign websites
 - Verified npm artifact across macOS and Ubuntu on Node.js 20 and 22

package/README.md

@@ -120,12 +120,23 @@ Useful commands:
 | `hive status` | Report whether Hive is running and its local address. |
 | `hive open` | Open an already-running dashboard. |
 | `hive stop` | Gracefully stop Hive. |
+| `hive update --check` | Check npm for a newer Hive release without changing anything. |
+| `hive update` | Confirm and install the latest release, refreshing setup and restarting Hive when needed. |
+| `hive update --yes` | Install the latest release without an interactive confirmation. |
 | `hive --version` | Show the installed version. |
 
 ## Update or uninstall
 
 Update to the newest release:
 
+```bash
+hive update
+```
+
+Use `hive update --check` for a read-only version check or `hive update --yes` to skip confirmation. If Hive is running, the updater stops it gracefully and restarts it on the same port after installation. It also refreshes Hive's additive provider setup. Mission history and configuration remain in the platform data directory.
+
+You can still update directly through npm if the installed Hive command is unavailable:
+
 ```bash
 npm install --global @shanesaravia/hive@latest
 ```

package/dist/bin/hive.js

@@ -3,6 +3,7 @@ import { spawn, spawnSync } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { createInterface } from "node:readline/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
 const currentFile = fileURLToPath(import.meta.url);
 const sourceMode = currentFile.endsWith(".ts");
@@ -132,6 +133,42 @@ export function parseStartOptions(args) {
     }
     return { port, open };
 }
+export function parseUpdateOptions(args) {
+    const options = { check: false, assumeYes: false };
+    for (const arg of args) {
+        if (arg === "--check")
+            options.check = true;
+        else if (arg === "--yes")
+            options.assumeYes = true;
+        else
+            throw new Error(`Unknown update option: ${arg}`);
+    }
+    if (options.check && options.assumeYes) {
+        throw new Error("Use either `hive update --check` or `hive update --yes`, not both.");
+    }
+    return options;
+}
+export function compareVersions(left, right) {
+    const parse = (value) => {
+        const match = value.trim().replace(/^v/, "").match(/^(\d+)\.(\d+)\.(\d+)(?:-([^+]+))?/);
+        if (!match)
+            throw new Error(`Invalid package version: ${value}`);
+        return { numbers: match.slice(1, 4).map(Number), prerelease: match[4] };
+    };
+    const a = parse(left);
+    const b = parse(right);
+    for (let index = 0; index < a.numbers.length; index++) {
+        if (a.numbers[index] !== b.numbers[index])
+            return a.numbers[index] < b.numbers[index] ? -1 : 1;
+    }
+    if (a.prerelease === b.prerelease)
+        return 0;
+    if (!a.prerelease)
+        return 1;
+    if (!b.prerelease)
+        return -1;
+    return a.prerelease.localeCompare(b.prerelease);
+}
 function readRuntimeState() {
     try {
         const state = JSON.parse(fs.readFileSync(runtimePath(), "utf8"));
@@ -352,6 +389,124 @@ async function runStop() {
     clearRuntimeState(state.pid);
     console.log("Hive stopped.");
 }
+function npmExecutable() {
+    return process.platform === "win32" ? "npm.cmd" : "npm";
+}
+function latestPackageVersion() {
+    const result = spawnSync(npmExecutable(), ["view", "@shanesaravia/hive@latest", "version", "--json"], {
+        encoding: "utf8",
+        timeout: 30_000,
+    });
+    if (result.error || result.status !== 0) {
+        const detail = result.error?.message ?? result.stderr.trim() ?? "npm registry request failed";
+        throw new Error(`Could not check for Hive updates: ${detail}`);
+    }
+    const output = result.stdout.trim();
+    try {
+        const parsed = JSON.parse(output);
+        if (typeof parsed === "string")
+            return parsed;
+    }
+    catch {
+        if (output)
+            return output;
+    }
+    throw new Error("Could not read the latest Hive version from npm.");
+}
+async function confirmUpdate(current, latest) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        throw new Error("Confirmation requires an interactive terminal. Re-run with `hive update --yes`.");
+    }
+    const prompt = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = await prompt.question(`Update Hive ${current} → ${latest}? [y/N] `);
+        return /^(y|yes)$/i.test(answer.trim());
+    }
+    finally {
+        prompt.close();
+    }
+}
+async function waitForRuntime(port, timeoutMs = 12_000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (await health(port))
+            return;
+        await new Promise((resolve) => setTimeout(resolve, 150));
+    }
+    throw new Error(`Hive did not restart on port ${port} within ${timeoutMs / 1000} seconds.`);
+}
+async function relaunchUpdatedHive(port) {
+    const child = spawn(process.execPath, [currentFile, "start", "--port", String(port), "--no-open"], {
+        detached: true,
+        stdio: "ignore",
+    });
+    child.unref();
+    await waitForRuntime(port);
+    console.log(`Hive restarted at http://127.0.0.1:${port}`);
+}
+async function runUpdate(args) {
+    const options = parseUpdateOptions(args);
+    if (sourceMode) {
+        throw new Error("`hive update` is only available from the globally installed CLI. Update a source checkout with Git instead.");
+    }
+    const current = packageVersion();
+    const latest = latestPackageVersion();
+    const comparison = compareVersions(current, latest);
+    if (comparison >= 0) {
+        console.log(comparison === 0
+            ? `Hive ${current} is already the latest version.`
+            : `Hive ${current} is newer than the npm latest version (${latest}).`);
+        return;
+    }
+    console.log(`Hive ${latest} is available (installed: ${current}).`);
+    if (options.check)
+        return;
+    if (!options.assumeYes && !(await confirmUpdate(current, latest))) {
+        console.log("Update cancelled.");
+        return;
+    }
+    const state = readRuntimeState();
+    const wasRunning = Boolean(state && processExists(state.pid));
+    const restartPort = state?.port ?? defaultPort;
+    if (wasRunning)
+        await runStop();
+    let updateError;
+    try {
+        const install = spawnSync(npmExecutable(), ["install", "--global", "@shanesaravia/hive@latest"], { stdio: "inherit" });
+        if (install.error || install.status !== 0) {
+            throw new Error(install.error?.message ?? `npm install exited with code ${install.status ?? "unknown"}`);
+        }
+        const installed = spawnSync(process.execPath, [currentFile, "--version"], { encoding: "utf8" });
+        if (installed.error || installed.status !== 0) {
+            throw new Error("Hive was installed, but the updated CLI could not be verified.");
+        }
+        const installedVersion = installed.stdout.trim();
+        if (compareVersions(installedVersion, latest) < 0) {
+            throw new Error(`npm completed, but Hive ${installedVersion} is still installed; expected ${latest}.`);
+        }
+        const setup = spawnSync(process.execPath, [currentFile, "setup", "--yes"], { stdio: "inherit" });
+        if (setup.error || setup.status !== 0) {
+            throw new Error("Hive updated, but provider setup could not be refreshed. Run `hive setup --yes` manually.");
+        }
+        console.log(`Hive updated successfully: ${current} → ${installedVersion}`);
+    }
+    catch (error) {
+        updateError = error;
+    }
+    if (wasRunning) {
+        try {
+            await relaunchUpdatedHive(restartPort);
+        }
+        catch (restartError) {
+            if (updateError) {
+                throw new Error(`${updateError.message} Hive also failed to restart: ${restartError.message}`);
+            }
+            throw restartError;
+        }
+    }
+    if (updateError)
+        throw updateError;
+}
 function commandVersion(command) {
     const result = spawnSync(command, ["--version"], { encoding: "utf8", timeout: 3_000 });
     if (result.error || result.status !== 0)
@@ -453,6 +608,7 @@ Usage:
   hive status                              Show whether Hive is running
   hive open                                Open the running dashboard
   hive stop                                Gracefully stop a recorded Hive server
+  hive update [--check] [--yes]            Check for or install the latest release
   hive --version                           Print the installed version
   hive --help                              Show this help
 
@@ -471,6 +627,7 @@ export async function main(argv = process.argv.slice(2)) {
         case "status": return runStatus();
         case "open": return runOpen();
         case "stop": return runStop();
+        case "update": return runUpdate(args);
         case "--version":
         case "-v":
             console.log(packageVersion());

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shanesaravia/hive",
   "private": false,
-  "version": "0.1.0",
+  "version": "0.1.1",
   "type": "module",
   "description": "Provider-neutral local mission control for Claude Code, Codex, and agent fleets.",
   "license": "MIT",