privateer-agent 0.12.0 → 0.12.2

package/README.md

@@ -275,8 +275,11 @@ a guarantee.
 
 ## Privateer account (billed inference)
 
-Instead of bringing your own key, run **`/signin`** to sign into a Privateer account — an
-app-brokered device flow where you approve a short code in the Privateer app, so wallet and
+Instead of bringing your own key, run **`/signin`** to sign into a Privateer account. Your
+browser opens straight onto an **Authorize this terminal?** page on privateer.pro — check the
+code on the page matches the one in your terminal and click Authorize; the terminal signs
+itself in moments later. (Over SSH or on a headless box the terminal prints the link and code
+to approve from the app instead — set `PRIVATEER_NO_BROWSER=1` to always do that.) Wallet and
 email accounts work identically and no password or key ever touches the terminal. Inference
 is then billed to your subscription and defaults to a **NEAR TEE** model. Sign out any time
 with `/signout`; manage linked terminals from the app.
@@ -293,10 +296,11 @@ and a management surface for it.
 
 ### Linking a terminal
 
-1. Run **`privateer`** and **`/signin`**. It prints a short device code.
-2. Open the app → **Link a terminal**, enter the code (or tap the deep link). No password or
-   wallet key ever touches the terminal, and the app pins the terminal's public key on first
-   link.
+1. Run **`privateer`** and **`/signin`**. Your browser opens an authorize page — check the
+   code matches the terminal's and click **Authorize**. (No browser handy? The terminal also
+   prints the link and code: open the app → **Link a terminal** and enter it there.) No
+   password or wallet key ever touches the terminal, and the app pins the terminal's public
+   key on first link.
 3. In the terminal, turn on **`/remote-access`** (off by default). The terminal now shows
    **Online** in the app.
 

package/bin/privateer-launch.mjs

@@ -143,23 +143,83 @@ function runToCompletion(cmd, cmdArgs, opts = {}) {
   });
 }
 
+// npm gives no usable progress, so on a TTY show a braille spinner while it runs
+// and keep its output buffered — shown only if the install fails. Non-TTY (CI,
+// piped) keeps the old passthrough behaviour. The global package is replaced in
+// place, so re-reading our own package.json afterwards yields the NEW version.
+function updateNpmPackage() {
+  const cmd = isWin ? "npm.cmd" : "npm";
+  const npmArgs = ["install", "-g", "privateer-agent@latest", "--no-fund", "--no-audit"];
+  if (!process.stdout.isTTY) {
+    console.log("Updating privateer-agent to the latest release…");
+    // npm is npm.cmd on Windows; Node >=18.20 needs a shell to spawn a .cmd (EINVAL otherwise).
+    runToCompletion(cmd, npmArgs, { shell: isWin });
+    return;
+  }
+  // Ask npm for the globally installed version — REPO/package.json would lie when
+  // this copy runs from somewhere other than the global root (e.g. an npx cache).
+  const globalVer = () => {
+    try {
+      const r = spawnSync(cmd, ["ls", "-g", "privateer-agent", "--depth=0", "--json"], { shell: isWin, encoding: "utf8" });
+      return JSON.parse(r.stdout).dependencies?.["privateer-agent"]?.version ?? null;
+    } catch { return null; }
+  };
+  const before = globalVer();
+  console.log(`\x1b[1m⚓ Updating Privateer\x1b[0m${before ? ` \x1b[2m(currently ${before})\x1b[0m` : ""}`);
+  const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+  let captured = "";
+  const child = spawn(cmd, [...npmArgs, "--loglevel=error"], { shell: isWin, env: process.env });
+  child.stdout.on("data", (d) => (captured += d));
+  child.stderr.on("data", (d) => (captured += d));
+  process.stdout.write("\x1b[?25l");
+  const t0 = Date.now();
+  let i = 0;
+  const timer = setInterval(() => {
+    const s = Math.round((Date.now() - t0) / 1000);
+    process.stdout.write(`\r  \x1b[36m${frames[i++ % frames.length]}\x1b[0m updating privateer-agent@latest \x1b[2m${s}s\x1b[0m\x1b[K`);
+  }, 80);
+  const restore = () => { clearInterval(timer); process.stdout.write("\r\x1b[K\x1b[?25h"); };
+  child.on("exit", (code, signal) => {
+    restore();
+    if (code === 0) {
+      const after = globalVer();
+      if (before && after && before === after) {
+        console.log(`\x1b[32m✓\x1b[0m Already ship-shape — privateer-agent ${after} is the latest release.`);
+      } else {
+        console.log(`\x1b[32m✓\x1b[0m Updated privateer-agent${before ? ` ${before} →` : ""}${after ? ` ${after}` : ""}`);
+        console.log(`\nRun \x1b[1mprivateer\x1b[0m to set sail on the new release.`);
+      }
+      process.exit(0);
+    }
+    if (captured.trim()) process.stderr.write(captured);
+    if (signal) process.kill(process.pid, signal);
+    else process.exit(code ?? 1);
+  });
+  child.on("error", (e) => {
+    restore();
+    console.error(`privateer: failed to launch npm — ${e.message}`);
+    process.exit(1);
+  });
+}
+
 // --- `privateer update` ----------------------------------------------------
 // Fetch the latest release and exit. Bundle installs re-run the download+extract
 // installer; npm installs update the global package.
 if (sub === "update") {
   if (BUNDLED) {
-    console.log("Updating Privateer to the latest release…");
+    // PRIVATEER_UPDATE=1 flips the installer into update mode: weigh-anchor banner,
+    // "X → Y" version reporting, and an early exit (no download) when already current.
+    // ?update=1 tells the server this fetch is an update, not a fresh install.
+    const env = { ...process.env, PRIVATEER_UPDATE: "1" };
     if (isWin) {
-      runToCompletion("powershell", ["-NoProfile", "-Command", "irm https://privateer.pro/install.ps1 | iex"]);
+      runToCompletion("powershell", ["-NoProfile", "-Command", "irm 'https://privateer.pro/install.ps1?update=1' | iex"], { env });
     } else {
-      runToCompletion("sh", ["-c", "curl -fsSL https://privateer.pro/install.sh | sh"]);
+      runToCompletion("sh", ["-c", "curl -fsSL 'https://privateer.pro/install.sh?update=1' | sh"], { env });
     }
   } else {
-    console.log("Updating privateer-agent to the latest release…");
-    // npm is npm.cmd on Windows; Node >=18.20 needs a shell to spawn a .cmd (EINVAL otherwise).
-    runToCompletion(isWin ? "npm.cmd" : "npm", ["install", "-g", "privateer-agent@latest"], { shell: isWin });
+    updateNpmPackage();
   }
-  // runToCompletion exits via the child's exit handler.
+  // both paths exit via their child's exit handler.
 }
 
 // --- `privateer harbor [run|install|uninstall|status]` ---------------------

package/extensions/privateer-brand.ts

@@ -35,6 +35,7 @@ import {
   verificationLink,
 } from "../src/providers/account.ts";
 import { resolveSignedInModel, savedPiDefaultSpec } from "../src/providers/defaultModel.ts";
+import { canOpenBrowser, openInBrowser } from "../src/util/openBrowser.ts";
 import { discoverContextFiles, onContextChanged } from "../src/context.ts";
 import { type Palette, paletteFor } from "../src/ui/palette.ts";
 
@@ -382,13 +383,22 @@ export default function privateerBrand(pi: any): void {
           // user copies into a browser. See providers/account.ts verificationLink.
           const uri = clean(verificationLink(code.verification_uri_complete ?? code.verification_uri));
           const userCode = clean(code.user_code);
+          // Browser-first sign-in: the URL carries the code, so the page opens straight
+          // onto the Authorize screen — the user clicks, never types. Best-effort and
+          // fire-and-forget: the copy below decides its wording SYNCHRONOUSLY off
+          // canOpenBrowser (SSH/headless → the old app-approve copy), and the printed
+          // link stays either way, so a launcher that silently fails costs nothing.
+          const opening = Boolean(uri) && canOpenBrowser();
+          if (opening) void openInBrowser(uri);
           ctx?.ui?.setWidget?.(
             "privateer-signin",
             [
               `${p.INK}⚓ Sign in to Privateer${p.RESET}`,
-              `${p.DIM}Approve this terminal in the Privateer app:${p.RESET}`,
-              `   code   ${p.BOLD}${p.ACCENT}${userCode}${p.RESET}`,
-              uri ? `${p.DIM}   or open ${p.RESET}${p.INK}${uri}${p.RESET}` : "",
+              opening
+                ? `${p.DIM}Authorize this terminal in the browser window that just opened.${p.RESET}`
+                : `${p.DIM}Approve this terminal in the Privateer app:${p.RESET}`,
+              `   code   ${p.BOLD}${p.ACCENT}${userCode}${p.RESET}${opening ? `${p.DIM} — check it matches the one in your browser${p.RESET}` : ""}`,
+              uri ? `${p.DIM}   ${opening ? "no browser? open" : "or open"} ${p.RESET}${p.INK}${uri}${p.RESET}` : "",
               `${p.DIM}   waiting for approval… ${p.RESET}${p.DIM}(esc to cancel · ${p.RESET}${p.INK}/login keys${p.DIM} to use your own API key instead)${p.RESET}`,
             ].filter(Boolean),
             { placement: "aboveEditor" },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "privateer-agent",
-  "version": "0.12.0",
+  "version": "0.12.2",
   "description": "Privacy-first terminal coding agent — bring your own model across 20 providers (Anthropic, OpenAI, OpenRouter, Google, local Ollama…). Safe-by-default permissions, MCP, sub-agents, workflows, and verifiable TEE inference. Built on the Pi toolkit.",
   "type": "module",
   "license": "MIT",

package/src/providers/account.ts

@@ -25,6 +25,7 @@ import {
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { globalDir } from "../config/paths.ts";
+import { canOpenBrowser, openInBrowser } from "../util/openBrowser.ts";
 import { interpretReport, teePosture, tierFromTeePosture, type PrivacyTier } from "pi-privacy";
 import { ACCOUNT_DEFAULT_MODEL_ID, ACCOUNT_NEAR_MODEL_ID, ensurePiDefaultModel } from "./defaultModel.ts";
 import {
@@ -398,15 +399,21 @@ export const privateerOAuthProvider = {
       try {
         await runDeviceLogin({
           signal: cb.signal,
-          onCode: (code) =>
+          onCode: (code) => {
+            // Absolute url — the server's value is scheme-less and Pi renders this as
+            // a terminal hyperlink. See verificationLink.
+            const uri = verificationLink(code.verification_uri_complete ?? code.verification_uri);
+            // Browser-first: the URL carries the code, so the page lands on the
+            // Authorize screen and the user just clicks. Best-effort fire-and-forget —
+            // Pi's dialog keeps showing the code + link as the fallback either way.
+            if (uri && canOpenBrowser()) void openInBrowser(uri);
             cb.onDeviceCode?.({
               userCode: code.user_code,
-              // Absolute url — the server's value is scheme-less and Pi renders this as
-              // a terminal hyperlink. See verificationLink.
-              verificationUri: verificationLink(code.verification_uri_complete ?? code.verification_uri),
+              verificationUri: uri,
               intervalSeconds: code.interval,
               expiresInSeconds: code.expires_in,
-            }),
+            });
+          },
         });
       } catch (e) {
         // Normalize the cancel message to exactly "Login cancelled" (no period):

package/src/util/openBrowser.ts

@@ -0,0 +1,90 @@
+// Best-effort "open this URL in the user's default browser", for the sign-in flow.
+//
+// The device-code login used to only PRINT the verification link and wait; opening
+// the browser ourselves turns /login into the one-click authorize flow (the page the
+// server sends carries the code in its query string, so the user just clicks
+// Authorize — no typing). Everything here is best-effort by design: the printed link
+// stays in the widget as the fallback, so a failed or skipped open costs nothing.
+//
+// Two separate questions, two exports:
+//   canOpenBrowser() — SHOULD we try? Decides the widget copy up front ("check the
+//     code matches your browser" vs "approve in the Privateer app"), so it must be
+//     synchronous and conservative: an SSH session or a display-less Linux box would
+//     open the browser on the WRONG machine or not at all.
+//   openInBrowser()  — actually try, detached, never throwing. The spawned launcher
+//     is unref()'d so a lingering handler can't hold the CLI's event loop open.
+
+import { spawn } from "node:child_process";
+
+export function canOpenBrowser(
+  env: Record<string, string | undefined> = process.env,
+  platform: NodeJS.Platform = process.platform,
+): boolean {
+  if (env.PRIVATEER_NO_BROWSER?.trim()) return false; // explicit escape hatch
+  // Remote shell: `open`/`xdg-open` would run on the far machine, not where the
+  // user's browser is. SSH_TTY covers interactive sessions; SSH_CONNECTION also
+  // survives `ssh host command` and some su/sudo transitions.
+  if (env.SSH_TTY || env.SSH_CONNECTION) return false;
+  // Headless Linux/BSD: no display server → nothing for xdg-open to hand the URL to.
+  if (platform !== "darwin" && platform !== "win32" && !env.DISPLAY && !env.WAYLAND_DISPLAY) return false;
+  return true;
+}
+
+// Only well-formed http(s) URLs are ever handed to a launcher — anything else
+// (including a scheme-less server value that slipped past verificationLink) is
+// refused rather than "fixed" here, so this can't be talked into opening file:// or
+// custom-scheme handlers.
+export function browsableUrl(raw: string | undefined): string | undefined {
+  const s = (raw ?? "").trim();
+  if (!s) return undefined;
+  try {
+    const u = new URL(s);
+    if (u.protocol !== "https:" && u.protocol !== "http:") return undefined;
+    return u.href;
+  } catch {
+    return undefined;
+  }
+}
+
+export function openInBrowser(rawUrl: string): Promise<boolean> {
+  const url = browsableUrl(rawUrl);
+  if (!url) return Promise.resolve(false);
+
+  let cmd: string;
+  let args: string[];
+  if (process.platform === "darwin") {
+    cmd = "open";
+    args = [url];
+  } else if (process.platform === "win32") {
+    // `start` is a cmd built-in; the empty "" is its window-title slot so the URL
+    // isn't eaten as the title. cmd re-parses its arguments, so escape the one URL
+    // metacharacter cmd cares about (& splits commands); browsableUrl already
+    // guarantees there's no whitespace or quotes to break out with.
+    cmd = "cmd";
+    args = ["/c", "start", "", url.replace(/&/g, "^&")];
+  } else {
+    cmd = "xdg-open";
+    args = [url];
+  }
+
+  return new Promise((resolve) => {
+    let settled = false;
+    const done = (ok: boolean) => {
+      if (!settled) {
+        settled = true;
+        resolve(ok);
+      }
+    };
+    try {
+      const child = spawn(cmd, args, { stdio: "ignore", detached: true });
+      child.once("error", () => done(false)); // launcher missing (e.g. no xdg-open)
+      child.once("exit", (code) => done(code === 0));
+      child.unref();
+      // Some launchers block until the browser exits; don't make the login widget
+      // wait on that — after a beat, assume the hand-off worked.
+      setTimeout(() => done(true), 2000).unref?.();
+    } catch {
+      done(false);
+    }
+  });
+}