privateer-agent 0.12.1 → 0.12.3

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.3",
   "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/auth/privateer.ts

@@ -451,8 +451,14 @@ export async function runDeviceLogin(opts: {
 // Pass the server's own message through so the user learns what to actually do.
 async function spawnFailure(res: Response): Promise<Error> {
   if (res.status === 401) {
-    clearCredentials();
-    notifySessionExpired();
+    // Announce only the signed-in → signed-out transition: concurrent launch-time
+    // spawns (warmSession + the account-channel seed) can both 401 on the same dead
+    // login, and whichever lands second must stay silent. Same guard as
+    // handleServerRevoke.
+    if (hasCredentials()) {
+      clearCredentials();
+      notifySessionExpired();
+    }
     return new Error("Your Privateer session expired. Run /login to sign in again.");
   }
   let message: string | undefined;

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 {
@@ -55,6 +56,10 @@ const DEFAULT_MODELS = [
   "anthropic/claude-sonnet-5",
   "openai/gpt-5.6-sol",
   "deepseek/deepseek-v4-flash",
+  // 2026-08 releases, confirmed live on OpenRouter (ZDR-covered ids reach the
+  // account catalog automatically; these seeds just make them resolve at launch).
+  "moonshotai/kimi-k3",
+  "z-ai/glm-5.2",
 ];
 
 function seedModel(id: string) {
@@ -398,15 +403,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):
@@ -809,7 +820,10 @@ export async function armAccountCredential(
     // so staying silent leaves the user to discover it as a bare "No API key found for
     // privateer" on their first prompt.
     const c = ctx as SeedContext;
-    if (opts.notify !== false && c?.hasUI) {
+    // If the credentials vanished during the call, the spawn hit a 401 and
+    // onSessionExpired already announced the sign-out — a second line here would
+    // just repeat it (we returned early above if we STARTED signed out).
+    if (opts.notify !== false && c?.hasUI && hasCredentials()) {
       c.ui?.notify?.(`Privateer account channel unavailable — ${(e as Error).message}`, "error");
     }
     return false;

package/src/providers/catalog.ts

@@ -59,7 +59,7 @@ export const PROVIDERS: ProviderEntry[] = [
     api: "openai-completions",
     keyEnv: "${DASHSCOPE_API_KEY}",
     compat: { thinkingFormat: "qwen" },
-    seedModels: ["qwen3-max", "qwen3-coder-plus", "qwen-max-latest"],
+    seedModels: ["qwen3.8-max-preview", "qwen3-max", "qwen3-coder-plus", "qwen-max-latest"],
   },
   { id: "ollama", source: "pi-privacy" },
   { id: "nearai", source: "pi-privacy" },

package/src/providers/genModelsJson.ts

@@ -36,6 +36,13 @@ export interface ModelsJson {
   providers: Record<string, ModelsJsonProvider>;
 }
 
+// Per-id context-window overrides for seeds whose real window is far from the
+// Appendix A.4 default (kept until the live listing refines them). Qwen3.8-Max
+// serves ~1M tokens (983,616 advertised at launch, 2026-08-03).
+const SEED_CONTEXT: Record<string, number> = {
+  "qwen3.8-max-preview": 1_000_000,
+};
+
 function seedModel(id: string, compat?: Record<string, unknown>): ModelsJsonModel {
   return {
     id,
@@ -43,7 +50,7 @@ function seedModel(id: string, compat?: Record<string, unknown>): ModelsJsonMode
     reasoning: false,
     input: ["text"],
     cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-    contextWindow: 128000,
+    contextWindow: SEED_CONTEXT[id] ?? 128000,
     maxTokens: 16384,
     ...(compat ? { compat } : {}),
   };

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);
+    }
+  });
+}