@tollbooth-dpyc/web 1.8.2 → 1.9.0

package/dist/client.d.ts

@@ -3,9 +3,9 @@
  *
  * 1. One @modelcontextprotocol/sdk Client over StreamableHTTP, shared by the
  *    whole page. The SDK handles the initialize handshake and the session.
- * 2. Auth is the uniform npub proof, by one of two tactics, invisible to
- *    callers: a session nsec signs a fresh kind-27235 proof per call, bound to
- *    the runtime tool name; otherwise the DM proof token cached at
+ * 2. Identity rides on the connection, invisible to callers: while this tab
+ *    holds the signed-in npub's key, every request is signed with it (NIP-98)
+ *    and a call names only the npub. Otherwise the DM proof token cached at
  *    `receive_npub_proof` is sent as is.
  * 3. Bootstrap tools take no envelope and are safe before sign-in.
  */

package/dist/client.js

@@ -3,9 +3,9 @@
  *
  * 1. One @modelcontextprotocol/sdk Client over StreamableHTTP, shared by the
  *    whole page. The SDK handles the initialize handshake and the session.
- * 2. Auth is the uniform npub proof, by one of two tactics, invisible to
- *    callers: a session nsec signs a fresh kind-27235 proof per call, bound to
- *    the runtime tool name; otherwise the DM proof token cached at
+ * 2. Identity rides on the connection, invisible to callers: while this tab
+ *    holds the signed-in npub's key, every request is signed with it (NIP-98)
+ *    and a call names only the npub. Otherwise the DM proof token cached at
  *    `receive_npub_proof` is sent as is.
  * 3. Bootstrap tools take no envelope and are safe before sign-in.
  */
@@ -14,9 +14,8 @@ import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/
 import { tollboothConfig, toolName } from "./config.js";
 import { debugPush, redact } from "./debugLog.js";
 import { clearStoredProof, forgetRecentLogin, getStoredNpub, getStoredProof, } from "./identity.js";
-import { signInlineProof } from "./inlineProof.js";
 import { isTransportFailure, NetworkError } from "./networkError.js";
-import { clearSessionNsec, hasSessionNsec, sessionNsecNpub } from "./sessionNsec.js";
+import { signingFetch, signsForSignedInNpub } from "./requestSigning.js";
 import { errorText, deadGrantMessage, looksFailed, proofBounceMessage, readToolResult, } from "./toolResult.js";
 /**
  * Standard tools whose wheel signature takes no npub/proof envelope. Pydantic
@@ -56,7 +55,7 @@ async function getClient() {
         // call, and nothing reached the server until the page was reloaded.
         connecting = (async () => {
             const c = new Client({ name: `${tollboothConfig().slug}-frontend`, version: "1" });
-            await c.connect(new StreamableHTTPClientTransport(new URL(mcpUrl())));
+            await c.connect(new StreamableHTTPClientTransport(new URL(mcpUrl()), { fetch: signingFetch }));
             client = c;
         })().finally(() => {
             connecting = null;
@@ -68,23 +67,18 @@ async function getClient() {
     return client;
 }
 /**
- * The proof for one call: a fresh inline proof when this tab's session key
- * derives to the signed-in npub, else the cached DM token. A session key left
- * from a previous identity is evicted rather than allowed to sign.
+ * What a call adds to prove the npub: nothing when the request itself is
+ * signed with the signed-in npub's key, else the cached DM token.
  */
-function proofFor(tool) {
+function proofFor() {
     try {
-        const npub = getStoredNpub();
-        const sessionNpub = hasSessionNsec() ? sessionNsecNpub() : null;
-        if (sessionNpub && sessionNpub === npub)
-            return { token: signInlineProof(toolName(tool)), inline: true };
-        if (sessionNpub)
-            clearSessionNsec();
+        if (signsForSignedInNpub())
+            return {};
     }
     catch {
         /* fall through to the cached token */
     }
-    return { token: getStoredProof(), inline: false };
+    return { dpop_token: getStoredProof() };
 }
 export { isNetworkError, NetworkError } from "./networkError.js";
 /** A paid call bounced for a lapsed or missing proof. The gate re-arms sign-in. */
@@ -131,10 +125,8 @@ export async function callToolWithContent(tool, args = {}, opts = {}) {
     if (!quiet)
         debugPush("call", `${name}(${redact(JSON.stringify(args)).slice(0, 140)})`);
     const bootstrap = STANDARD_BOOTSTRAP.includes(tool) || cfg.extraBootstrapTools.includes(tool);
-    const proof = bootstrap ? null : proofFor(tool);
-    const merged = proof
-        ? { npub: getStoredNpub(), dpop_token: proof.token, ...args }
-        : { ...args };
+    const proof = bootstrap ? null : proofFor();
+    const merged = proof ? { npub: getStoredNpub(), ...proof, ...args } : { ...args };
     let result;
     try {
         const c = await getClient();
@@ -168,7 +160,7 @@ export async function callToolWithContent(tool, args = {}, opts = {}) {
     // from a best-effort call: that is not a blip, and staying "signed in" on a
     // dead grant leaves every page failing with nothing to tell them why.
     const bounced = (opts.bestEffort ? null : proofBounceMessage(payload)) ??
-        (proof && !proof.inline && proof.token ? deadGrantMessage(payload) : null);
+        (proof?.dpop_token ? deadGrantMessage(payload) : null);
     if (bounced !== null) {
         // The token just refused is the same one the recent-login shortcut
         // would replay, so it goes too, or a returning patron re-bounces.

package/dist/config.d.ts

@@ -19,6 +19,12 @@ export interface TollboothConfig {
      * origin, which is how every site reaches its Pages proxy.
      */
     mcpUrl: string;
+    /**
+     * The operator's own origin, e.g. "https://goodearth-mcp.fastmcp.app". When
+     * set, a patron who signs in by DM connects as a holder there: the grant
+     * stays with the operator and the page names only the npub.
+     */
+    operatorUrl?: string;
     /**
      * Free tools this operator adds that take no npub/proof envelope, on top of
      * the standard ones. Pydantic rejects unexpected kwargs, so a tool listed
@@ -32,7 +38,8 @@ export interface TollboothConfig {
     /** How long a page sits untouched before its guided tour is offered, in ms. Defaults to 10 s. */
     tourIdleMs?: number;
 }
-interface Resolved extends Required<Omit<TollboothConfig, "extraBootstrapTools" | "quietTools" | "avatarChoices" | "tourIdleMs">> {
+interface Resolved extends Required<Omit<TollboothConfig, "extraBootstrapTools" | "quietTools" | "avatarChoices" | "tourIdleMs" | "operatorUrl">> {
+    operatorUrl?: string;
     extraBootstrapTools: string[];
     quietTools: string[];
     avatarChoices?: string[];

package/dist/config.js

@@ -17,6 +17,7 @@ export function configureTollbooth(config) {
         appName: config.appName,
         storagePrefix: config.storagePrefix ?? config.slug,
         mcpUrl: config.mcpUrl,
+        operatorUrl: config.operatorUrl,
         extraBootstrapTools: config.extraBootstrapTools ?? [],
         quietTools: config.quietTools ?? [],
         avatarChoices: config.avatarChoices,

package/dist/holder.d.ts

@@ -0,0 +1,31 @@
+/**
+ * This tab as a *holder*: a connection the operator knows, into whose wallet
+ * npubs are proven by DM. A patron who signs in by DM — holding no key — is
+ * proven this way, and the grant stays with the operator; the page holds only
+ * the connection's OAuth tokens and names the npub on each call.
+ *
+ * Becoming a holder is the OAuth Authorization Code flow every MCP client
+ * runs: register, send the browser to the operator's `/authorize` (it approves
+ * at once, since a holder holds nothing until a DM proves an npub into it),
+ * and exchange the code it hands back. Tokens refresh on their own; a refresh
+ * token is single-use, so each refresh stores the pair it returns.
+ */
+/** True when this site connects as a holder (its operator supports it). */
+export declare function holderEnabled(): boolean;
+/** True when this tab already is a holder. */
+export declare function isHolder(): boolean;
+/**
+ * Become a holder: register and send the browser to the operator, which
+ * sends it straight back. `resume` comes back from `completeHolderConnect`.
+ */
+export declare function connectAsHolder(resume: string): Promise<void>;
+/**
+ * On return from the operator: exchange the code, store the tokens, tidy the
+ * address bar, and hand back what the sign-in was doing. Null when this page
+ * load is not a return.
+ */
+export declare function completeHolderConnect(): Promise<string | null>;
+/** The bearer for the next request, refreshed when it is about to lapse; null when not a holder. */
+export declare function holderBearer(): Promise<string | null>;
+/** Disconnect: the operator forgets this holder and every npub it held. */
+export declare function forgetHolder(): Promise<void>;

package/dist/holder.js

@@ -0,0 +1,162 @@
+/**
+ * This tab as a *holder*: a connection the operator knows, into whose wallet
+ * npubs are proven by DM. A patron who signs in by DM — holding no key — is
+ * proven this way, and the grant stays with the operator; the page holds only
+ * the connection's OAuth tokens and names the npub on each call.
+ *
+ * Becoming a holder is the OAuth Authorization Code flow every MCP client
+ * runs: register, send the browser to the operator's `/authorize` (it approves
+ * at once, since a holder holds nothing until a DM proves an npub into it),
+ * and exchange the code it hands back. Tokens refresh on their own; a refresh
+ * token is single-use, so each refresh stores the pair it returns.
+ */
+import { tollboothConfig } from "./config.js";
+import { readStored, removeStored, writeStored } from "./storage.js";
+const TOKENS = "holder:v1";
+const PENDING = "holder_pending:v1";
+/** Refresh this long before the access token lapses. */
+const REFRESH_EARLY_MS = 60_000;
+function operator() {
+    const url = tollboothConfig().operatorUrl;
+    if (!url)
+        throw new Error("operatorUrl is not configured.");
+    return url.replace(/\/+$/, "");
+}
+/** True when this site connects as a holder (its operator supports it). */
+export function holderEnabled() {
+    return Boolean(tollboothConfig().operatorUrl);
+}
+function redirectUri() {
+    return `${globalThis.location.origin}/`;
+}
+function readTokens() {
+    try {
+        const t = JSON.parse(readStored(TOKENS) || "null");
+        return t && typeof t.accessToken === "string" && typeof t.refreshToken === "string" ? t : null;
+    }
+    catch {
+        return null;
+    }
+}
+function writeTokens(t) {
+    writeStored(TOKENS, JSON.stringify(t));
+}
+function randomUrlSafe(bytes) {
+    const raw = crypto.getRandomValues(new Uint8Array(bytes));
+    return btoa(String.fromCharCode(...raw)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+async function challengeFor(verifier) {
+    const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier)));
+    return btoa(String.fromCharCode(...digest)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+async function register() {
+    const r = await fetch(`${operator()}/register`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            client_name: tollboothConfig().appName,
+            redirect_uris: [redirectUri()],
+            grant_types: ["authorization_code", "refresh_token"],
+            response_types: ["code"],
+            token_endpoint_auth_method: "none",
+        }),
+    });
+    if (!r.ok)
+        throw new Error(`Could not register with the service (${r.status}).`);
+    return (await r.json()).client_id;
+}
+async function token(form, clientId) {
+    const r = await fetch(`${operator()}/token`, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({ ...form, client_id: clientId, resource: `${operator()}/mcp` }),
+    });
+    if (!r.ok)
+        throw new Error(`The service refused the connection (${r.status}).`);
+    const t = await r.json();
+    return {
+        clientId,
+        accessToken: t.access_token,
+        refreshToken: t.refresh_token,
+        expiresAt: Date.now() + Number(t.expires_in ?? 3600) * 1000,
+    };
+}
+/** True when this tab already is a holder. */
+export function isHolder() {
+    return readTokens() !== null;
+}
+/**
+ * Become a holder: register and send the browser to the operator, which
+ * sends it straight back. `resume` comes back from `completeHolderConnect`.
+ */
+export async function connectAsHolder(resume) {
+    const clientId = readTokens()?.clientId || (await register());
+    const verifier = randomUrlSafe(48);
+    const state = randomUrlSafe(16);
+    const pending = { clientId, verifier, state, resume };
+    globalThis.sessionStorage.setItem(PENDING, JSON.stringify(pending));
+    const url = new URL(`${operator()}/authorize`);
+    url.search = new URLSearchParams({
+        response_type: "code",
+        client_id: clientId,
+        redirect_uri: redirectUri(),
+        state,
+        code_challenge: await challengeFor(verifier),
+        code_challenge_method: "S256",
+        resource: `${operator()}/mcp`,
+    }).toString();
+    globalThis.location.assign(url.toString());
+}
+/**
+ * On return from the operator: exchange the code, store the tokens, tidy the
+ * address bar, and hand back what the sign-in was doing. Null when this page
+ * load is not a return.
+ */
+export async function completeHolderConnect() {
+    const params = new URLSearchParams(globalThis.location.search);
+    const code = params.get("code");
+    const raw = globalThis.sessionStorage.getItem(PENDING);
+    if (!code || !raw)
+        return null;
+    globalThis.sessionStorage.removeItem(PENDING);
+    const pending = JSON.parse(raw);
+    globalThis.history.replaceState(null, "", globalThis.location.pathname);
+    if (params.get("state") !== pending.state)
+        throw new Error("The service's reply did not match this sign-in.");
+    writeTokens(await token({ grant_type: "authorization_code", code, redirect_uri: redirectUri(), code_verifier: pending.verifier }, pending.clientId));
+    return pending.resume;
+}
+/** The bearer for the next request, refreshed when it is about to lapse; null when not a holder. */
+export async function holderBearer() {
+    const t = readTokens();
+    if (!t)
+        return null;
+    if (t.expiresAt - REFRESH_EARLY_MS > Date.now())
+        return t.accessToken;
+    try {
+        const fresh = await token({ grant_type: "refresh_token", refresh_token: t.refreshToken }, t.clientId);
+        writeTokens(fresh);
+        return fresh.accessToken;
+    }
+    catch {
+        removeStored(TOKENS);
+        return null;
+    }
+}
+/** Disconnect: the operator forgets this holder and every npub it held. */
+export async function forgetHolder() {
+    const t = readTokens();
+    removeStored(TOKENS);
+    if (!t)
+        return;
+    try {
+        await fetch(`${operator()}/revoke`, {
+            method: "POST",
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body: new URLSearchParams({ token: t.refreshToken, token_type_hint: "refresh_token", client_id: t.clientId }),
+        });
+    }
+    catch {
+        /* the tokens are gone from this tab; the operator lets them lapse */
+    }
+}

package/dist/identity.js

@@ -8,6 +8,7 @@
  *     name into the identity slot before it was proven is what once let an
  *     unanswered challenge become a session.
  */
+import { forgetHolder, isHolder } from "./holder.js";
 import { clearSessionNsec, hasSessionNsec, sessionNsecNpub } from "./sessionNsec.js";
 import { canSignFor, isProven } from "./signedIn.js";
 import { readStored, removeStored, writeStored } from "./storage.js";
@@ -83,12 +84,21 @@ export function forgetRecentLogin(npub) {
 // ─── The claim ───────────────────────────────────────────────────────────
 /** Read once and handed to the pure predicates in `signedIn.ts`. */
 export function currentClaim() {
+    const npub = getStoredNpub();
     return {
-        npub: getStoredNpub(),
+        npub,
         proof: getStoredProof(),
+        held: heldByThisTab(npub),
         sessionNpub: hasSessionNsec() ? sessionNsecNpub() : null,
     };
 }
+/**
+ * True when this tab's holder connection holds `npub`: a DM sign-in recorded
+ * here with no token, because the operator kept the grant.
+ */
+function heldByThisTab(npub) {
+    return Boolean(npub) && isHolder() && getValidRecentLogins().some((e) => e.npub === npub && !e.proof);
+}
 export function isLoggedIn() {
     return isProven(currentClaim());
 }
@@ -103,4 +113,5 @@ export function logOut() {
     removeStored(NPUB);
     removeStored(PROOF);
     clearSessionNsec();
+    void forgetHolder();
 }

package/dist/index.d.ts

@@ -4,7 +4,7 @@ export type { ImageBlock } from "./toolResult.ts";
 export * from "./identity.ts";
 export * from "./standardTools.ts";
 export { clearSessionNsec, getSessionNsec, getSessionNsecBytes, hasSessionNsec, sessionNsecNpub, setSessionNsec, } from "./sessionNsec.ts";
-export { signInlineProof } from "./inlineProof.ts";
+export { signRequest } from "./requestSigning.ts";
 export { sessionKeyClaimVisible } from "./sessionKeyClaim.ts";
 export { handOffMode, shareOrDownload, type ShareOutcome } from "./shareFile.ts";
 export { canSignFor, isProven, type Claim } from "./signedIn.ts";

package/dist/index.js

@@ -3,7 +3,7 @@ export { callTool, callToolWithContent, isNetworkError, NetworkError, onProofExp
 export * from "./identity.js";
 export * from "./standardTools.js";
 export { clearSessionNsec, getSessionNsec, getSessionNsecBytes, hasSessionNsec, sessionNsecNpub, setSessionNsec, } from "./sessionNsec.js";
-export { signInlineProof } from "./inlineProof.js";
+export { signRequest } from "./requestSigning.js";
 export { sessionKeyClaimVisible } from "./sessionKeyClaim.js";
 export { handOffMode, shareOrDownload } from "./shareFile.js";
 export { canSignFor, isProven } from "./signedIn.js";

package/dist/react/NpubGate.js

@@ -16,6 +16,7 @@ import { useEffect, useRef, useState } from "react";
 import { generateSecretKey, getPublicKey, nip19 } from "nostr-tools";
 import { tollboothConfig } from "../config.js";
 import { forgetRecentLogin, getLastTypedNpub, getValidRecentLogins, recordRecentLogin, setLastTypedNpub, setStoredNpub, setStoredProof, } from "../identity.js";
+import { completeHolderConnect, connectAsHolder, holderEnabled, isHolder } from "../holder.js";
 import { setSessionNsec } from "../sessionNsec.js";
 import { readSignInFailure } from "../signInSituation.js";
 import { receiveNpubProof, requestNpubProof } from "../standardTools.js";
@@ -106,22 +107,45 @@ export default function NpubGate({ onLogin, startFresh = false, operatorHash, no
             setError(`Couldn't read that nsec: ${e.message}`);
         }
     }
-    async function begin() {
-        if (!isNpub) {
+    // Back from connecting to the operator: carry on with the DM it was for.
+    const resumed = useRef(false);
+    useEffect(() => {
+        if (resumed.current)
+            return;
+        resumed.current = true;
+        completeHolderConnect()
+            .then((npub) => {
+            if (npub) {
+                setValue(npub);
+                void begin(npub);
+            }
+        })
+            .catch((e) => setError(e.message));
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    async function begin(npubArg) {
+        const npubToProve = npubArg ?? trimmed;
+        if (!(npubToProve.startsWith("npub1") && npubToProve.length >= 60)) {
             setError("Enter a valid npub1… key.");
             return;
         }
         setBusy(true);
         setError("");
         try {
-            const r = await requestNpubProof(trimmed, globalThis.location.origin, `You requested to sign in to ${appName} (${globalThis.location.host}).`);
+            // The grant will stay with the operator, so this tab connects to it
+            // first; the browser comes straight back here and the DM goes out.
+            if (holderEnabled() && !isHolder()) {
+                await connectAsHolder(npubToProve);
+                return;
+            }
+            const r = await requestNpubProof(npubToProve, globalThis.location.origin, `You requested to sign in to ${appName} (${globalThis.location.host}).`);
             if (r.error)
                 return setError(r.error);
             if (!r.dpop_token)
                 return setError("The service did not return a session phrase. Try again.");
             // Remembered for the field only. The identity is written by `finish()`,
             // once the human has answered the DM.
-            setLastTypedNpub(trimmed);
+            setLastTypedNpub(npubToProve);
             setPendingProof(r.dpop_token);
             setStage("awaiting");
         }
@@ -143,7 +167,9 @@ export default function NpubGate({ onLogin, startFresh = false, operatorHash, no
                 setStage("awaiting");
                 return;
             }
-            const token = r.dpop_token || pendingProof;
+            // A holder's grant stays with the operator; only a page that is not a
+            // holder keeps the token it is handed.
+            const token = r.held_by_connection ? "" : r.dpop_token || pendingProof;
             const npub = r.proven_npub || trimmed;
             setStoredNpub(npub);
             setStoredProof(token);

package/dist/requestSigning.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Every request a page sends while it holds the signed-in npub's key is signed
+ * with that key (NIP-98): an `Authorization: Nostr` event bound to the method,
+ * the URL and the sha256 of the body. Whoever holds the key needs no grant, and
+ * no tool call carries a proof in its arguments.
+ */
+/**
+ * 16 random bytes as 32 lowercase hex chars. Without it two requests signed in
+ * the same wall-clock second could be byte-identical, their ids would collide,
+ * and the server's replay guard would refuse the second.
+ */
+export declare function proofNonce(): string;
+/** The `Authorization` value for one request, signed by `secretKey`. */
+export declare function signRequest(method: string, url: string, body: string, secretKey: Uint8Array): Promise<string>;
+/**
+ * True when this tab holds the key of the npub that is signed in. A key left
+ * from a previous identity is evicted rather than allowed to sign.
+ */
+export declare function signsForSignedInNpub(): boolean;
+/**
+ * `fetch` for the MCP transport: the request carries who it may act as — this
+ * tab's key when it holds one, else this tab's holder connection, else nobody
+ * (the site's proxy then marks it anonymous).
+ */
+export declare const signingFetch: typeof fetch;

package/dist/requestSigning.js

@@ -0,0 +1,71 @@
+/**
+ * Every request a page sends while it holds the signed-in npub's key is signed
+ * with that key (NIP-98): an `Authorization: Nostr` event bound to the method,
+ * the URL and the sha256 of the body. Whoever holds the key needs no grant, and
+ * no tool call carries a proof in its arguments.
+ */
+import { finalizeEvent } from "nostr-tools";
+import { holderBearer } from "./holder.js";
+import { getStoredNpub } from "./identity.js";
+import { clearSessionNsec, getSessionNsecBytes, hasSessionNsec, sessionNsecNpub } from "./sessionNsec.js";
+const PROOF_KIND = 27235;
+/**
+ * 16 random bytes as 32 lowercase hex chars. Without it two requests signed in
+ * the same wall-clock second could be byte-identical, their ids would collide,
+ * and the server's replay guard would refuse the second.
+ */
+export function proofNonce() {
+    const bytes = crypto.getRandomValues(new Uint8Array(16));
+    return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function sha256Hex(body) {
+    const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(body));
+    return Array.from(new Uint8Array(digest), (b) => b.toString(16).padStart(2, "0")).join("");
+}
+/** The `Authorization` value for one request, signed by `secretKey`. */
+export async function signRequest(method, url, body, secretKey) {
+    const event = finalizeEvent({
+        kind: PROOF_KIND,
+        created_at: Math.floor(Date.now() / 1000),
+        tags: [
+            ["u", url],
+            ["method", method.toUpperCase()],
+            ["payload", await sha256Hex(body)],
+            ["nonce", proofNonce()],
+        ],
+        content: "",
+    }, secretKey);
+    return `Nostr ${btoa(JSON.stringify(event))}`;
+}
+/**
+ * True when this tab holds the key of the npub that is signed in. A key left
+ * from a previous identity is evicted rather than allowed to sign.
+ */
+export function signsForSignedInNpub() {
+    const sessionNpub = hasSessionNsec() ? sessionNsecNpub() : null;
+    if (!sessionNpub)
+        return false;
+    if (sessionNpub === getStoredNpub())
+        return true;
+    clearSessionNsec();
+    return false;
+}
+/**
+ * `fetch` for the MCP transport: the request carries who it may act as — this
+ * tab's key when it holds one, else this tab's holder connection, else nobody
+ * (the site's proxy then marks it anonymous).
+ */
+export const signingFetch = async (input, init) => {
+    const headers = new Headers(init?.headers);
+    if (signsForSignedInNpub()) {
+        const request = new Request(input, init);
+        const body = typeof init?.body === "string" ? init.body : "";
+        headers.set("Authorization", await signRequest(request.method, request.url, body, getSessionNsecBytes()));
+    }
+    else {
+        const bearer = await holderBearer();
+        if (bearer)
+            headers.set("Authorization", `Bearer ${bearer}`);
+    }
+    return fetch(input, { ...init, headers });
+};

package/dist/signedIn.d.ts

@@ -6,9 +6,10 @@
  * "signed in" let anyone who asked for a DM and never answered it in, as
  * themselves, unproven. Two things can back the claim:
  *
- *   - a **cached DM proof**, won by answering a Nostr challenge, or
- *   - a **session nsec** in this tab, which signs a fresh proof per call — and
- *     only counts for the npub it actually derives to.
+ *   - a **DM proof**, won by answering a Nostr challenge — held by the operator
+ *     for this tab's connection, or (before holders) cached here, or
+ *   - a **session nsec** in this tab, which signs every request — and only
+ *     counts for the npub it actually derives to.
  *
  * Pure, so it is testable without a browser.
  */
@@ -17,10 +18,12 @@ export interface Claim {
     npub: string;
     /** A cached DM proof token, if one was won and has not lapsed. */
     proof: string;
+    /** True when this tab's holder connection holds the npub, proven by DM. */
+    held: boolean;
     /** The npub this tab's session key derives to, if it holds one. */
     sessionNpub: string | null;
 }
 /** True only when the claimed npub is backed by something. */
-export declare function isProven({ npub, proof, sessionNpub }: Claim): boolean;
+export declare function isProven({ npub, proof, held, sessionNpub }: Claim): boolean;
 /** True when this tab can sign a fresh proof for the npub it is claiming. */
 export declare function canSignFor({ npub, sessionNpub }: Claim): boolean;

package/dist/signedIn.js

@@ -6,17 +6,18 @@
  * "signed in" let anyone who asked for a DM and never answered it in, as
  * themselves, unproven. Two things can back the claim:
  *
- *   - a **cached DM proof**, won by answering a Nostr challenge, or
- *   - a **session nsec** in this tab, which signs a fresh proof per call — and
- *     only counts for the npub it actually derives to.
+ *   - a **DM proof**, won by answering a Nostr challenge — held by the operator
+ *     for this tab's connection, or (before holders) cached here, or
+ *   - a **session nsec** in this tab, which signs every request — and only
+ *     counts for the npub it actually derives to.
  *
  * Pure, so it is testable without a browser.
  */
 /** True only when the claimed npub is backed by something. */
-export function isProven({ npub, proof, sessionNpub }) {
+export function isProven({ npub, proof, held, sessionNpub }) {
     if (!npub)
         return false;
-    if (proof)
+    if (proof || held)
         return true;
     return sessionNpub === npub;
 }

package/dist/standardTools.d.ts

@@ -54,6 +54,8 @@ export interface NpubProofResult {
     status?: string;
     message?: string;
     dpop_token?: string;
+    /** True when the operator kept the grant for this tab's holder connection. */
+    held_by_connection?: boolean;
     expires_in_seconds?: number;
     expires_at?: string;
     error?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tollbooth-dpyc/web",
-  "version": "1.8.2",
+  "version": "1.9.0",
   "description": "Shared browser SDK for Tollbooth DPYC operator front ends: npub sign-in, proofs, MCP client, profile and wallet",
   "license": "Apache-2.0",
   "author": "Lonnie VanZandt",

package/dist/inlineProof.d.ts

@@ -1,18 +0,0 @@
-/**
- * Inline kind-27235 identity proof — Tactic 2 in the wheel's
- * `identity_proof.verify_proof`. A fresh signed event per paid call, bound to:
- * the sender pubkey (must match the claimed npub), the `u` tag (must match the
- * runtime tool name, e.g. "chart_snapshot_display"), and `created_at` (within
- * about 60 seconds of server time). The wheel verifies the Schnorr signature
- * inline — no relay round trip, no cached phrase.
- *
- * Every proof also carries a random `nonce` tag, exactly as the wheel's own
- * `create_proof` does. Without it, two calls to the same tool in the same
- * wall-clock second sign byte-identical events, their ids collide, and the
- * verifier's replay guard refuses the second. The nonce is signed but inert:
- * `verify_proof` reads only the `u` tag.
- */
-/** 16 random bytes as 32 lowercase hex chars — Python's `secrets.token_hex(16)`. */
-export declare function proofNonce(): string;
-/** The JSON-stringified signed event, exactly what `verify_proof` expects. */
-export declare function signInlineProof(runtimeToolName: string, secretKey?: Uint8Array): string;

package/dist/inlineProof.js

@@ -1,35 +0,0 @@
-/**
- * Inline kind-27235 identity proof — Tactic 2 in the wheel's
- * `identity_proof.verify_proof`. A fresh signed event per paid call, bound to:
- * the sender pubkey (must match the claimed npub), the `u` tag (must match the
- * runtime tool name, e.g. "chart_snapshot_display"), and `created_at` (within
- * about 60 seconds of server time). The wheel verifies the Schnorr signature
- * inline — no relay round trip, no cached phrase.
- *
- * Every proof also carries a random `nonce` tag, exactly as the wheel's own
- * `create_proof` does. Without it, two calls to the same tool in the same
- * wall-clock second sign byte-identical events, their ids collide, and the
- * verifier's replay guard refuses the second. The nonce is signed but inert:
- * `verify_proof` reads only the `u` tag.
- */
-import { finalizeEvent } from "nostr-tools";
-import { getSessionNsecBytes } from "./sessionNsec.js";
-const PROOF_KIND = 27235;
-/** 16 random bytes as 32 lowercase hex chars — Python's `secrets.token_hex(16)`. */
-export function proofNonce() {
-    const bytes = crypto.getRandomValues(new Uint8Array(16));
-    return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
-}
-/** The JSON-stringified signed event, exactly what `verify_proof` expects. */
-export function signInlineProof(runtimeToolName, secretKey) {
-    const signed = finalizeEvent({
-        kind: PROOF_KIND,
-        created_at: Math.floor(Date.now() / 1000),
-        tags: [
-            ["u", runtimeToolName],
-            ["nonce", proofNonce()],
-        ],
-        content: "",
-    }, secretKey ?? getSessionNsecBytes());
-    return JSON.stringify(signed);
-}