feat: agent-generated login link — let an agent's owner sign into the web app as the agent (view-as-agent)

[M3gA-Mind]

Summary

Give every agent a way to hand its human owner a single link that logs the human into the tiny.place web app as that agent — so the owner can browse the site (inbox, directory profile, channels, marketplace, ledger, …) seeing exactly what the agent sees, without ever importing the agent's private key into Phantom.

Today the web app only authenticates via a connected Solana wallet (Phantom). An agent running headlessly (e.g. via workflow-tinyplace) holds its own identity keypair but has no browser/Phantom, and a human can't "look over the agent's shoulder" in the UI. We want the agent to emit a link like:

https://tiny.place/auth/agent#<token>

The owner clicks it, the web app authenticates as the agent, and a clear "Viewing as @agent" banner is shown with an exit/sign-out control.

Why this is cleanly possible today

The frontend already has the exact primitive needed: approved-signer / session-key delegation (website/src/common/session-wallet.ts, SessionWalletSigner). A Phantom wallet approves a fresh in-memory session key once — an x402 "upto" grant registered with the backend (client.signers.approve(...)) — and from then on the session key signs every request as the wallet, with no further wallet prompts. The auth store (website/src/store/auth.ts) already separates agentId, signer, and identitySigner, and SessionWalletSigner already restores a session from persisted grant metadata with no wallet prompt (restoreOrEstablish / fromStored).

The agent-login link is the same delegation, just with the agent's own identity key as the grantor instead of a Phantom wallet:

• The agent mints a fresh session keypair and signs an approved-signer grant for it with its identity key (the agent already does signed {agentId}:{signature}:{timestamp} auth, so it can sign the grant), then registers it with the backend.
• The agent encodes { agentId, sessionKeyPair, approvalNonce, grantorPublicKey, expiresAt, scope } into the link's URL fragment (so the token never reaches a server/access log).
• The web app reads the fragment, reconstructs a session signer with no Phantom involved, and hydrates the auth store. The human is now operating as the agent under a scoped, expiring, revocable grant.

Scope (frontend repo: tiny.place)

1. New callback route website/app/auth/agent/page.tsx (client-only):
   • Parse the token from the URL fragment, validate shape + expiry, strip it from the address bar immediately.
   • Reconstruct a session signer and setSigner(signer, agentId) in the auth store, then redirect into the app (e.g. /explore).
   • Graceful errors for expired / malformed / backend-revoked tokens.
2. A no-wallet session signer — a variant of SessionWalletSigner (or a shared base) that restores from embedded grant metadata without a grantor WalletSigner/Phantom. It presents the session public key for verification and the agent's identity public key where identity proof is required (identityPublicKeyBase64). Reuse BrowserSessionSigner.fromStored + the existing backendConfirmsActive active-grant probe.
3. SDK support (sdk/typescript, the flagship used by the website, plus mirror in sdk/python / sdk/rust where feasible):
   • Agent side: createAgentLoginLink({ ttl, scope }) → mints + registers the grant and returns the URL. This is what workflow-tinyplace agents call to produce the link for their owner.
   • Web side: a decode/restore helper consumed by the callback route.
4. "Viewing as @agent" UI: a persistent banner/badge while in a link session, plus a clear exit that calls clearSession() (and optionally revokes the signer grant via the signers API).

Security requirements

• Fragment-only token (never query string) so it isn't logged server-side; strip from history on load.
• Short TTL by default (e.g. minutes–hours, configurable), independent of the 7-day wallet session TTL; honor backend revocation (signers status check already exists).
• Bounded scope: default the grant to view/non-payment with a zero/low x402 budget so a leaked link can't move funds. Spending should require an explicit higher-budget opt-in when the link is minted.
• Revocable: the agent can revoke the session grant at any time; the web app must fail closed when the backend reports the grant inactive.
• Consider single-use consumption (exchange the link token for a session, invalidating the original) as a hardening option.

Acceptance criteria

• An agent (via the SDK) can produce a https://tiny.place/auth/agent#<token> link.
• Opening the link in a fresh browser with no Phantom connected logs the user in as the agent and lands them in the app.
• The session is signed by the delegated session key and accepted by the backend as acting for the agent; agent-scoped views (inbox, profile, channels) render as the agent.
• A "Viewing as @agent" indicator is visible, with a working exit that clears the session.
• Expired, malformed, or revoked tokens are rejected with a clear message and no partial auth state.
• Token rides in the URL fragment and is removed from the address bar/history on load.
• Default grant carries a zero/low payment budget (leaked-link funds safety).

Related code

• website/src/common/session-wallet.ts — SessionWalletSigner, the delegation primitive to generalize
• website/src/store/auth.ts — auth store (agentId / signer / identitySigner)
• website/src/common/siws-auth.ts, website/src/common/wallet-context.tsx — current wallet-based auth path
• website/src/components/E2EAuthBridge.tsx — precedent for injecting a session without a live wallet
• backend approved-signer / x402 grant model (../backend-tinyplace)