privateer-agent 0.3.2 → 0.3.4

package/README.md

@@ -12,6 +12,9 @@
   <a href="https://www.npmjs.com/package/privateer-agent">
     <img src="https://img.shields.io/npm/v/privateer-agent" alt="npm" />
   </a>
+  <a href="https://github.com/privateer-agent/privateer-agent/releases">
+    <img src="https://img.shields.io/badge/changelog-what's%20new-5b8def" alt="Changelog" />
+  </a>
   <img src="https://img.shields.io/badge/node-%E2%89%A522.19-brightgreen" alt="Node >= 22.19" />
   <img src="https://img.shields.io/badge/license-MIT-blue" alt="MIT License" />
   <img src="https://img.shields.io/badge/permissions-safe%20by%20default-2ea44f" alt="Safe by default" />
@@ -247,6 +250,12 @@ npm run typecheck
 npm test
 ```
 
+## Changelog
+
+Release notes and what's new in each version live on the
+[**GitHub releases page**](https://github.com/privateer-agent/privateer-agent/releases).
+Privateer keeps its startup clean — the app won't dump a changelog into your terminal.
+
 ## License
 
 [MIT](LICENSE) © Patrick

package/bin/privateer-tui

@@ -18,6 +18,15 @@ while [ -h "$SOURCE" ]; do
 done
 REPO="$(cd -P "$(dirname "$SOURCE")/.." && pwd)"
 
+# `privateer update` — pull the latest release from npm and exit. Handled here in the
+# launcher (not the TUI) so it works even when a broken install won't boot. npm rewrites
+# the global bin in place; replacing it while this process runs is safe on unix.
+if [ "${1:-}" = "update" ]; then
+  echo "Updating privateer-agent to the latest release…"
+  npm install -g privateer-agent@latest
+  exit $?
+fi
+
 pick_node() {
   if command -v node >/dev/null 2>&1 \
      && node -e 'process.exit((+process.versions.node.split(".")[0]) >= 22 ? 0 : 1)' 2>/dev/null; then
@@ -59,17 +68,46 @@ shim pi-subagents      "$REPO/node_modules/pi-subagents/src/extension/index.ts"
 
 CLI="$REPO/node_modules/@earendil-works/pi-coding-agent/dist/cli.js"
 export PI_CODING_AGENT_DIR="$AGENT_DIR"
+# Suppress Pi's upstream "Update Available — run `pi update`" banner. It's noise on a
+# Privateer install (our banner is the startup surface), it leaks the "pi" name, and
+# `pi update` would fight our npm-managed install. PI_SKIP_VERSION_CHECK disables ONLY
+# the version fetch — unlike PI_OFFLINE it still lets fd/rg download on first run.
+export PI_SKIP_VERSION_CHECK=1
 NODE_BIN="$(pick_node)"
 
-# Quiet Pi's built-in startup resource listing ([Extensions]/[Context]/[Skills]/…) by
-# default — our banner is the intended startup surface, and the extension list is noise.
-# Only set it when unset, so a later `--verbose` or a user's own settings toggle sticks.
+# Quiet Pi's built-in startup chatter so our banner is the only greeting. Each key is
+# set only when unset, so a user's own settings.json toggle (or --verbose) still wins:
+#   quietStartup       — hide the [Extensions]/[Context]/[Skills]/… resource listing
+#   collapseChangelog  — never dump Pi's "What's New" changelog wall into the chat
+#   lastChangelogVersion — sentinel so Pi finds no "new" entries to show on upgrade;
+#                          release notes live in the npm README / GitHub releases instead
 "$NODE_BIN" -e '
 const fs = require("fs"), p = process.argv[1];
 let s = {}; try { s = JSON.parse(fs.readFileSync(p, "utf8")); } catch {}
-if (s.quietStartup === undefined) { s.quietStartup = true; fs.writeFileSync(p, JSON.stringify(s, null, 2) + "\n"); }
+let m = false;
+if (s.quietStartup === undefined) { s.quietStartup = true; m = true; }
+if (s.collapseChangelog === undefined) { s.collapseChangelog = true; m = true; }
+if (s.lastChangelogVersion === undefined) { s.lastChangelogVersion = "9999.0.0"; m = true; }
+if (m) fs.writeFileSync(p, JSON.stringify(s, null, 2) + "\n");
 ' "$AGENT_DIR/settings.json" 2>/dev/null || true
 
+# Passive update check: refresh the cached "latest npm version" at most ~daily, in the
+# BACKGROUND so it never blocks or breaks launch (offline-safe — a failed fetch just
+# leaves the stale cache in place). The banner (privateer-brand) reads this cache and
+# shows a one-line "↑ vX available · run privateer update" notice when we're behind. We
+# never auto-install — the user stays in control of when new code lands (the whole point
+# of an attestable tool). Detached with </dev/null &, so it outlives our exec into node.
+UPDATE_CACHE="${PRIVATEER_HOME:-$HOME/.privateer}/update-check.json"
+if [ -z "$(find "$UPDATE_CACHE" -mtime -1 2>/dev/null)" ]; then
+  (
+    latest="$(npm view privateer-agent version 2>/dev/null || true)"
+    case "$latest" in
+      [0-9]*) printf '{"latest":"%s"}\n' "$latest" > "$UPDATE_CACHE.tmp" 2>/dev/null \
+                && mv -f "$UPDATE_CACHE.tmp" "$UPDATE_CACHE" 2>/dev/null ;;
+    esac
+  ) </dev/null >/dev/null 2>&1 &
+fi
+
 # Default model: when signed in to a Privateer account, default to GLM 5.1 on the
 # account's NEAR confidential-compute (TEE) channel — attestable, strongest privacy
 # tier. Otherwise (BYO key, no account) fall back to a cheap OpenRouter model. An

package/extensions/privateer-brand.ts

@@ -9,15 +9,19 @@
 //      device-code flow the account channel needs.
 //
 // Pi already owns /login and /logout for PROVIDER auth (and /whoami), so we do NOT
-// shadow them. /signin drives the Privateer *account* device flow directly — which
-// has to exist separately, because the `privateer` inference provider only registers
-// once credentials exist, so a first-time user can't reach it through provider auth.
+// shadow them. The account provider now registers unconditionally (see
+// makeAccountProvider), so Privateer appears under Pi's /login "Use a subscription"
+// list and a first-time user CAN sign in through provider auth. /signin remains as a
+// friendlier, dedicated shortcut that drives the same account device-code flow
+// directly — one obvious command instead of /login → pick a provider.
 //
 // On a successful /signin we hot-register the account provider so privateer/* models
-// appear immediately, without a restart.
+// appear immediately (the account catalog refreshes to the live listing without a
+// restart).
 
 import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
+import { join } from "node:path";
 import * as priv from "../src/auth/privateer.ts";
 import { makeAccountProvider } from "../src/providers/account.ts";
 
@@ -54,7 +58,7 @@ const ANCHOR = [
   "  .-----.  ", // lock body top (the shackle's base)
   "  |  o  |  ", // lock body + keyhole
   "  '--+--'  ", // lock body base, shank exits
-  "  ---+---  ", // stock (crossbar)
+  "  /\\ | /\\  ", // stock — arms flare from the shank (each \\ is one backslash)
   "  \\  |  /  ", // arms
   "   \\_|_/   ", // flukes
 ];
@@ -102,6 +106,34 @@ function accountLine(modelProvider?: string): string {
   return `${DIM}not signed in · ${OCEAN_LIGHT}/signin${DIM} to connect your account${RESET}`;
 }
 
+// Is dotted version `a` newer than `b`? Plain numeric compare of major.minor.patch —
+// enough for our npm releases; anything unparseable sorts as 0 and is treated as older.
+function isNewer(a: string, b: string): boolean {
+  const pa = a.split(".").map((n) => parseInt(n, 10) || 0);
+  const pb = b.split(".").map((n) => parseInt(n, 10) || 0);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] ?? 0) > (pb[i] ?? 0)) return true;
+    if ((pa[i] ?? 0) < (pb[i] ?? 0)) return false;
+  }
+  return false;
+}
+
+// The "update available" banner line, or "" when we're current / offline / unchecked.
+// Reads the cache the launcher refreshes in the background (see bin/privateer-tui) —
+// never fetches here, so the banner stays synchronous and never blocks on the network.
+function updateNotice(): string {
+  try {
+    const home = process.env.PRIVATEER_HOME || join(homedir(), ".privateer");
+    const { latest } = JSON.parse(readFileSync(join(home, "update-check.json"), "utf8"));
+    if (typeof latest === "string" && isNewer(latest, VERSION)) {
+      return `${YELLOW}↑ v${latest} available${DIM} · run ${RESET}${OCEAN_LIGHT}privateer update${RESET}`;
+    }
+  } catch {
+    // no cache yet, unreadable, or malformed — show nothing.
+  }
+  return "";
+}
+
 // Compose the framed banner: anchor column + text column, inside a rounded accent box.
 function renderBanner(width: number, modelProvider?: string): string[] {
   // Leading blanks drop the text block so the wordmark sits beside the lock body and
@@ -116,8 +148,11 @@ function renderBanner(width: number, modelProvider?: string): string[] {
     `${DIM}privateer-agent ${OCEAN_LIGHT}v${VERSION}${RESET}`,
     `${OCEAN_LIGHT}${shortCwd()}${RESET}`,
   ];
-  // Build the body rows (anchor + gutter + text).
+  // Build the body rows (anchor + gutter + text). A pending-update notice, if any, gets
+  // its own row under the block, indented to sit beneath the text column.
   const rows = ANCHOR.map((a, i) => `${OCEAN}${a}${RESET}  ${right[i] ?? ""}`);
+  const notice = updateNotice();
+  if (notice) rows.push(`      ${notice}`);
   const cap = Math.max(20, width - 4); // 2 border cells + 2 padding
   const inner = Math.min(cap, Math.max(...rows.map(vlen)));
   const bar = "─".repeat(inner + 2);
@@ -150,7 +185,6 @@ function accountBadge(): string {
 export default function privateerBrand(pi: any): void {
   let currentModelProvider: string | undefined;
   let ctxRef: any = null;
-  let greeted = false;
 
   const setHeader = (ctx: any) =>
     ctx?.ui?.setHeader?.(() => headerComponent(currentModelProvider));
@@ -161,6 +195,31 @@ export default function privateerBrand(pi: any): void {
     ctx?.ui?.setStatus?.("account", accountBadge());
   };
 
+  // /update — run the global npm install in a child process and report the outcome via
+  // notify (the TUI keeps running the OLD code; npm swaps the global bin's inode in
+  // place, so replacing it under us is safe and the new version loads on next launch).
+  async function doUpdate(ctx: any): Promise<void> {
+    ctx?.ui?.notify?.("Updating Privateer — running npm install -g privateer-agent@latest…", "info");
+    try {
+      const { execFile } = await import("node:child_process");
+      const stderr: string = await new Promise((resolve, reject) => {
+        execFile(
+          "npm",
+          ["install", "-g", "privateer-agent@latest"],
+          { timeout: 180_000 },
+          (err, _out, errOut) => (err ? reject(new Error(String(errOut || err.message).trim())) : resolve(String(errOut || ""))),
+        );
+      });
+      void stderr;
+      ctx?.ui?.notify?.("Updated. Restart `privateer` to run the new version.", "info");
+    } catch (e) {
+      ctx?.ui?.notify?.(
+        `Update failed: ${(e as Error).message || e}. Try manually: npm install -g privateer-agent@latest`,
+        "error",
+      );
+    }
+  }
+
   async function doSignIn(ctx: any): Promise<void> {
     if (priv.hasCredentials()) {
       const u = priv.currentUser();
@@ -227,13 +286,8 @@ export default function privateerBrand(pi: any): void {
     if (!ctx?.hasUI) return; // headless (print/json): no banner or prompts
     ctx?.ui?.setTitle?.("Privateer");
     refresh(ctx);
-    if (!priv.hasCredentials() && !greeted) {
-      greeted = true;
-      ctx?.ui?.notify?.(
-        "Not signed in — run /signin to connect your Privateer account (adds hosted models + remote access).",
-        "info",
-      );
-    }
+    // No startup notify here: the banner's account line already surfaces the
+    // "not signed in · /signin" prompt, so a second line would just be noise.
   });
 
   // Keep the header's account line in sync with the picked model (the "this model
@@ -254,6 +308,10 @@ export default function privateerBrand(pi: any): void {
     ctxRef?.ui?.notify?.("Your Privateer session expired. Run /signin to sign back in.", "warning");
   });
 
+  pi.registerCommand?.("update", {
+    description: "Update Privateer to the latest release (npm i -g privateer-agent@latest)",
+    handler: (_args: string, ctx: any) => doUpdate(ctx),
+  });
   pi.registerCommand?.("signin", {
     description: "Sign in to your Privateer account (device-code flow)",
     handler: (_args: string, ctx: any) => doSignIn(ctx),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "privateer-agent",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "Privateer — a provider-agnostic, safe-by-default terminal coding agent with TEE/Tinfoil attestation, rebuilt on the Pi toolkit. Bring your own model across 20 providers.",
   "type": "module",
   "license": "MIT",

package/src/providers/account.ts

@@ -136,8 +136,16 @@ export async function accountPosture(modelId: string): Promise<AccountPosture> {
   }
 }
 
-// Extension factory: registers the account provider when a machine login exists. No
-// login → nothing registered (BYO-key only).
+// Extension factory: registers the account provider so `/login` can offer it.
+//
+// We register UNCONDITIONALLY (not only when a machine login already exists). Pi's
+// `/login` builds its "Use a subscription" list from the OAuth providers registered
+// here (authStorage.getOAuthProviders()); a not-yet-logged-in machine has no
+// credentials, so gating registration on hasCredentials() left `/login` with no
+// Privateer option — the classic chicken-and-egg where you can't log in because
+// you're not logged in. The OAuth provider's login() itself runs the device-code
+// flow when hasCredentials() is false (see privateerOAuthProvider.login), so first
+// login works entirely through Pi once the provider is present.
 //
 // Registration is SYNCHRONOUS (seeded with the fallback), then refined once the live
 // catalog is fetched. This matters: Pi flushes provider registrations made during the
@@ -151,7 +159,7 @@ export function makeAccountProvider() {
   return (pi: {
     registerProvider?: (name: string, config: unknown) => void;
   }): void => {
-    if (!hasCredentials() || typeof pi.registerProvider !== "function") return;
+    if (typeof pi.registerProvider !== "function") return;
     const register = (ids: string[]): void =>
       pi.registerProvider!("privateer", {
         name: "Privateer account",