privateer-agent 0.12.1 → 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/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.1",
+  "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);
+    }
+  });
+}