pendingyou 0.29.0 → 0.30.0

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.30.0 (2026-10-07)
+
+- This computer's own sign-ins (the connections `init` made for Claude Code, Codex, OpenCode and Pi) now last while
+  you use them. Each refresh carries a proof by this computer's key (a DPoP proof, RFC 9449, signed with the key in
+  `~/.config/pendingyou/machine.json`), and Pending You renews a sign-in for 30 days from that refresh when it's proven
+  by the key of the computer it's on. Before, every sign-in ended 30 days after it began, however much it was used. A
+  computer left unused for 30 days still signs out; Pending You says so 3 days before. Its tokens are unchanged, and a
+  refresh never fails for want of a proof: without a key, or when the proof isn't taken, it refreshes as before.
+
 ## 0.29.0 (2026-10-07)
 
 - The command line links this computer's sign-ins to it by its key, so Pending You names every assistant here by this

package/README.md

@@ -339,8 +339,8 @@ hold to approve. Pending You says on the card and to the agent "Answered in Herd
 Herdr (moving between panes, tabs and workspaces, or pressing keys in the popup) your phone stays quiet for those cards,
 as it does while Pending You is open on your desk.
 
-`npx pendingyou app status` says what each app signed in here may do and until when (a sign-in lasts 30 days; it warns
-in the last 3), and `npx pendingyou app logout herdr` ends Herdr's sign-in. Settings › Apps and devices in Pending You
+`npx pendingyou app status` says what each app signed in here may do and until when (a sign-in lasts 30 days from its
+last use here; it warns in the last 3), and `npx pendingyou app logout herdr` ends Herdr's sign-in. Settings › Apps and devices in Pending You
 lists it too, with Remove. It needs `init` to have run here first: this computer's key vouches for the sign-in.
 
 ## How Claude Code hears your answer
@@ -440,8 +440,8 @@ The machine is called by its Tailscale name when Tailscale is installed and runn
 else by its hostname, or by `--name build-01` on `init` or `login`; a Mac by its own name (Sharing in System Settings).
 A cloud's own hostname (AWS's `ip-10-42-1-252`) is kept when there's nothing better, and `login` says how to change it:
 `npx pendingyou login --name <name>` asks for one more approval and renames the connection, which stays the same one.
-If an agent's sign-in ends (30 days, or you remove it on your Assistants page), `npx pendingyou login` (`--app codex`
-for Codex's) approves a new code and keeps the same connection.
+If an agent's sign-in ends (30 days unused, or you remove it on your Assistants page), `npx pendingyou login`
+(`--app codex` for Codex's; `--force` while it still works) approves a new code and keeps the same connection.
 
 Only want this command's own sign-in (for `watch`, below)? `npx pendingyou login --device` signs it in with a code,
 hearing answers only, and adds no connection. Your phone asks "Let build-01 hear your answers for the assistants
@@ -527,8 +527,9 @@ The hooks use the same sign-in, and hand a session only the cards its own app po
 signs in by itself (`--oauth`, or one you kept) gets a sign-in that only hears its answers instead: it can't ask,
 answer or change anything, and doesn't show up as an assistant. They're stored in `~/.config/pendingyou/credentials.json`
 (readable only by you, in a folder with a `.gitignore` of `*` so a dotfiles repository never takes it), refresh
-themselves, and end after 30 days or on `logout`. The headers helper hands an agent's token only to that agent's
-Pending You (Claude Code says which server it's for; Codex's is the one `init` wrote). `clients.json` remembers which
+themselves, last 30 days from their last use (0.30.0: each refresh proves this computer's key, and Pending You renews
+the sign-in from then), and end once unused that long, or on `logout`. The headers helper hands an agent's token only
+to that agent's Pending You (Claude Code says which server it's for; Codex's is the one `init` wrote). `clients.json` remembers which
 sign-in each agent's connection used, so signing in again keeps it. `machine.json` (0.18.0) holds this computer's key
 pair, private like the rest; only its proofs leave the computer, each for one sign-in, once. `apps/<app>.json` (0.21.0)
 holds an app's own sign-in and the private key its tokens are bound to (DPoP), private like the rest; the Pending You

package/dist/api.js

@@ -33,8 +33,11 @@ async function refreshStored(io, origin, stored, options, app) {
             return current;
         if (!options.force && current.expiresAt - options.earlyMs > io.now())
             return current;
+        const prove = current.kind === 'connection'
+            ? await (await import("./machine.js")).machineProver(io)
+            : undefined;
         try {
-            const tokens = await refresh(io, origin, current.clientId, current.refreshToken);
+            const tokens = await refresh(io, origin, current.clientId, current.refreshToken, prove);
             return { ...current, ...tokens };
         }
         catch (error) {

package/dist/machine.js

@@ -7,6 +7,7 @@ import { PlainError } from "./errors.js";
 import { configDir, readJson, withLock, writeWhole } from "./files.js";
 import { discover } from "./oauth.js";
 import { machineOf } from "./remote.js";
+import { proof as dpopProof } from "./sdk/dpop.js";
 export const ATTESTATION_TYPE = 'pendingyou-machine+jwt';
 const ATTESTATION_SECONDS = 300;
 export const MACHINE_PATH = '/mcp/cli/machine';
@@ -100,6 +101,13 @@ export async function attest(machine, claims, now) {
     const signature = await webcrypto.subtle.sign({ name: 'ECDSA', hash: 'SHA-256' }, machine.signer, Buffer.from(signing));
     return `${signing}.${base64url(new Uint8Array(signature))}`;
 }
+export async function machineProver(io) {
+    const machine = await readMachine(io).catch(() => null);
+    if (!machine)
+        return undefined;
+    const key = { jwk: machine.jwk, jkt: machine.thumbprint, privateKey: machine.signer };
+    return ({ method, url, nonce, now }) => dpopProof(key, { method, url, now, ...(nonce ? { nonce } : {}) });
+}
 export async function keyForSignIn(io) {
     try {
         const { machine, made } = await ensureMachine(io);

package/dist/oauth.js

@@ -128,14 +128,28 @@ async function listen(state, signal) {
         },
     };
 }
-async function tokenRequest(io, metadata, params, timeoutMs = 20_000) {
-    const response = await io.fetch(metadata.token_endpoint, {
+async function tokenRequest(io, metadata, params, timeoutMs = 20_000, prove) {
+    const signal = AbortSignal.timeout(timeoutMs);
+    const send = async (dpop) => io.fetch(metadata.token_endpoint, {
         method: 'POST',
-        headers: { 'content-type': 'application/x-www-form-urlencoded', accept: 'application/json' },
+        headers: {
+            'content-type': 'application/x-www-form-urlencoded',
+            accept: 'application/json',
+            ...(dpop ? { dpop } : {}),
+        },
         body: new URLSearchParams(params).toString(),
-        signal: AbortSignal.timeout(timeoutMs),
+        signal,
     });
-    const body = (await response.json().catch(() => ({})));
+    const proof = (nonce) => (prove ? prove(nonce).catch(() => null) : null);
+    let response = await send(await proof());
+    let body = (await response.json().catch(() => ({})));
+    for (const again of ['nonce', 'plain']) {
+        if (body.error !== 'use_dpop_nonce')
+            break;
+        const nonce = response.headers.get('dpop-nonce');
+        response = await send(again === 'nonce' && nonce ? await proof(nonce) : null);
+        body = (await response.json().catch(() => ({})));
+    }
     if (!response.ok ||
         typeof body.access_token !== 'string' ||
         typeof body.refresh_token !== 'string') {
@@ -192,14 +206,21 @@ export async function signIn(io, options) {
         loopback.close();
     }
 }
-export async function refresh(io, origin, clientId, refreshToken) {
+export async function refresh(io, origin, clientId, refreshToken, prove) {
     const metadata = await discover(io, origin, 8_000);
     return tokenRequest(io, metadata, {
         grant_type: 'refresh_token',
         refresh_token: refreshToken,
         client_id: clientId,
         resource: resourceOf(origin),
-    }, 12_000);
+    }, 12_000, prove
+        ? (nonce) => prove({
+            method: 'POST',
+            url: metadata.token_endpoint,
+            now: serverNow(io, metadata),
+            ...(nonce ? { nonce } : {}),
+        })
+        : undefined);
 }
 export async function revoke(io, origin, clientId, refreshToken) {
     try {

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.29.0';
+export const VERSION = '0.30.0';

package/mod/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "pendingyou-wake",
   "displayName": "Pending You",
-  "version": "2.44.0",
+  "version": "2.44.1",
   "description": "Wakes Claude Code when your person answers a Pending You card it posted, even while it sits idle. Installed by `npx pendingyou init`.",
   "author": {
     "name": "RecordPlane",

package/mod/README.md

@@ -4,4 +4,4 @@ The pendingyou command line’s copy of the Pending You plugin’s wake mod, for
 
 In each session it learns the cards the session posts to Pending You, checks them through the session’s own Pending You connection, and starts a turn when your person answers, writes back or a fallback comes due, or hands the session a question from another of their assistants (CLI 0.14.0), even while it sits idle. It answers `npx pendingyou hold` itself, so nothing waits in the background, and shows “2 waiting on you” under the prompt, after the plugin’s name. With the Pending You plugin installed too, only one copy acts.
 
-Generated from recordplane/pendingyou (packages/claude-plugin/src/wake) with Pending You’s guide 2.44.0; send changes there.
+Generated from recordplane/pendingyou (packages/claude-plugin/src/wake) with Pending You’s guide 2.44.1; send changes there.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pendingyou",
-  "version": "0.29.0",
+  "version": "0.30.0",
   "description": "Pending You for your coding agents: one command sets up Claude Code, Codex, OpenCode and Pi to ask you through Pending You and hear your answers, even while they sit idle.",
   "license": "Apache-2.0",
   "homepage": "https://www.pendingyou.com",