a2a-exposed 0.8.7 → 0.8.8

package/lib/main.mjs

@@ -168,7 +168,7 @@ Inbox (owner side)
 Pairing (OAuth 2.0 device flow, RFC 8628: agents connect without pasting tokens into chat)
   connect <base-or-card-url> [--alias A] [--name N] [--card-url URL] [--replace] [--no-wait] [--json]
                           ask another A2A endpoint for a token: prints a code + link for your human (the code lasts
-                          10 minutes; they confirm the code with that A2A endpoint's owner), waits for approval, stores
+                          60 minutes; they confirm the code with that A2A endpoint's owner), waits for approval, stores
                           the token as outbound peer A
                           (never printed). --no-wait: print the code and exit; run the same command again to
                           check (same code). An expired code exits 1 (nothing new is requested silently).

package/lib/pair.mjs

@@ -364,7 +364,7 @@ A different agent at the same URL? Pass another --alias.`);
 		}
 		st = { base, alias, device: ep.device, token: ep.token, deviceCode: r.data.device_code, userCode: r.data.user_code,
 			verificationUri: r.data.verification_uri || "", verificationUriComplete: r.data.verification_uri_complete || r.data.verification_uri || "",
-			interval: Math.max(1, Number(r.data.interval) || 5), expiresAt: Date.now() + (Number(r.data.expires_in) || 600) * 1000,
+			interval: Math.max(1, Number(r.data.interval) || 5), expiresAt: Date.now() + (Number(r.data.expires_in) || 3600) * 1000,
 			replacesLabel: r.data.replaces_label || null, replacing: replace && !!oldToken };
 		saveState(alias, st); // chmod 600: the device code is a bearer secret until it is redeemed
 		const mins = Math.round((st.expiresAt - Date.now()) / 60000);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "a2a-exposed",
-	"version": "0.8.7",
+	"version": "0.8.8",
 	"description": "Give any AI agent a public A2A (Agent2Agent) endpoint: a Cloudflare Worker, a wake webhook, or scheduled checks",
 	"type": "module",
 	"bin": {

package/worker/cloudflare.config.ts

@@ -62,6 +62,8 @@ const plain: Record<string, string> = {
 	APPROVAL_OIDC_CLIENT_ID: v("APPROVAL_OIDC_CLIENT_ID"),
 	APPROVAL_OIDC_ALLOWED_SUBJECTS: v("APPROVAL_OIDC_ALLOWED_SUBJECTS"),
 	APPROVAL_METHODS: v("APPROVAL_METHODS"),
+	// Optional https URL of this agent's dashboard page. A pairing wake and the MCP inbox line include it as manageUrl.
+	MANAGE_URL: v("MANAGE_URL"),
 };
 const hosted = v("TENANCY") === "host";
 // Daily R2 snapshots. Unset: no binding and no extra cron, so a self-host deploy stays the single-tenant Worker.

package/worker/deploy.env.example

@@ -44,6 +44,9 @@ WAKE_PRESET=generic
 # APPROVAL_OIDC_ALLOWED_SUBJECTS=
 # APPROVAL_METHODS=password
 # Secrets (same secrets file, never here): APPROVAL_OIDC_CLIENT_SECRET.
+# Optional https URL of this agent's dashboard page. When set, a pairing wake and the MCP inbox line
+# include it as manageUrl.
+# MANAGE_URL=https://example.com/app/agents/name#pairing
 # Daily SQL snapshots to R2. Unset: no BACKUP_BUCKET binding and no extra cron. The minute wake cron stays A2A_ENABLE_CRON.
 # A2A_BACKUP_BUCKET=1
 # A2A_BACKUP_BUCKET_NAME=a2a-exposed-backups

package/worker/src/index.ts

@@ -11,7 +11,7 @@ import { fetchCheckedWake } from "./wake-target.ts";
 import * as P from "./pairing.ts";
 import * as M from "./mcp.ts";
 import { accountIdOf, DASHBOARD_ACTOR_HEADER, matchOwnerRpc, ownerResponseLeaks, scrubOwnerClaims, type OwnerRpcRequest, type OwnerRpcResult } from "./owner-rpc.ts";
-import { resolveTenant, type TenantContext, type WorkerBindings } from "./tenancy.ts";
+import { publicManageUrl, resolveTenant, type TenantContext, type WorkerBindings } from "./tenancy.ts";
 import { exportRows, redactExport, REDACTED_SQL_SKIP, scrubSecretText, toSql } from "./export.ts";
 import { backupDatabase, DAILY_CRON } from "./backup.ts";
 import * as O from "./approval-oidc.ts";
@@ -159,7 +159,7 @@ const WAKE_RETRIES = 3;
 /** The wake endpoint said 429 / 503 (e.g. a Claude Code routine over its fire limit): keep the inbound wake pending and
  *  flush it once Retry-After (30 s - 1 h) has passed, on the next request to the Worker or the optional cron. At most
  *  WAKE_RETRIES times per wake; a newer message for the conversation merges in and starts over. Pairing and test wakes
- *  are not retried (a pairing code expires in minutes). */
+ *  are not retried (a pairing code lasts 60 minutes). */
 async function requeueWake(ctx: TenantContext, ectx: ExecutionContext, payload: Json, retryAfter: string | null) {
 	if (payload.kind !== "inbound") return;
 	const attempts = (Number(payload.attempts) || 0) + 1;
@@ -1241,6 +1241,11 @@ async function bump(ctx: TenantContext, key: string, windowS: number, peek = fal
 
 const clientIp = (req: Request) => req.headers.get("cf-connecting-ip") || "";
 const clientCountry = (req: Request) => String(((req as Json).cf || {}).country || "");
+const clientTimeZone = (req: Request) => {
+	const zone = ((req as Json).cf || {}).timezone;
+	return typeof zone === "string" ? zone : "";
+};
+const dashboardUrl = (ctx: TenantContext) => publicManageUrl(ctx.MANAGE_URL);
 
 async function deviceAuthorization(req: Request, ctx: TenantContext, ectx: ExecutionContext): Promise<Response> {
 	const now = Date.now(), ip = clientIp(req);
@@ -1288,11 +1293,13 @@ async function deviceAuthorization(req: Request, ctx: TenantContext, ectx: Execu
 	const complete = `${u.page}?user_code=${shown}`;
 	log("pairing_requested", { ip, userCode: shown, clientName, clientId, ...(replaces ? { replaces: replaces.label } : {}) });
 	const mode = pairingMode(ctx) as "human" | "agent";
+	const manage = dashboardUrl(ctx);
 	ectx.waitUntil((async () => {
 		if (!(await wakeBudgetOk(ctx))) return log("wake_skipped", { reason: "hourly cap", kind: "pairing_request" });
 		await sendWake(ctx, ectx, { contextId: "pairing", taskId: "none", taskIds: [], from: clientName || clientId || "unknown agent", preview: "",
 			kind: "pairing_request", pairing: { userCode: shown, verificationUriComplete: complete, approval: mode, clientName, clientId, agentCardUrl: cardUrl,
 				...(cardUrl && P.cardIsPrivate(cardUrl) ? { agentCardPrivate: true } : {}), expiresIn: P.EXPIRES_S,
+				...(manage ? { manageUrl: manage } : {}),
 				...(replaces ? { replacesLabel: replaces.label } : {}) } });
 	})());
 	return json({ device_code: deviceCode, user_code: shown, verification_uri: u.page, verification_uri_complete: complete,
@@ -1439,7 +1446,7 @@ async function devicePage(req: Request, ctx: TenantContext, url: URL, head = fal
 	const fresh = !/^[A-Za-z0-9_-]{24}$/.test(csrf);
 	if (fresh) csrf = P.randomB64();
 	const pw = await approvalPassword(ctx);
-	const model: P.PageModel = { agentName: ctx.AGENT_NAME || "this A2A endpoint", mode: pairingMode(ctx), cli: cliCommand(ctx), csrf, passwordSet: !!pw, ...approvalPageBits(ctx) };
+	const model: P.PageModel = { agentName: ctx.AGENT_NAME || "this A2A endpoint", mode: pairingMode(ctx), cli: cliCommand(ctx), csrf, passwordSet: !!pw, timeZone: clientTimeZone(req), ...approvalPageBits(ctx) };
 	const send = (status = 200) => {
 		const h: Record<string, string> = P.pageHeaders(nonce, oidcFormOrigins(ctx));
 		h["set-cookie"] = `${csrfName}=${csrf}; Path=/device; Secure; HttpOnly; SameSite=Strict; Max-Age=3600`;
@@ -1546,7 +1553,7 @@ async function devicePage(req: Request, ctx: TenantContext, url: URL, head = fal
 async function deviceOidcCallback(req: Request, ctx: TenantContext, url: URL, head = false): Promise<Response> {
 	const nonce = P.randomB64();
 	const pw = await approvalPassword(ctx);
-	const model: P.PageModel = { agentName: ctx.AGENT_NAME || "this A2A endpoint", mode: pairingMode(ctx), cli: cliCommand(ctx), csrf: P.randomB64(), passwordSet: !!pw, ...approvalPageBits(ctx) };
+	const model: P.PageModel = { agentName: ctx.AGENT_NAME || "this A2A endpoint", mode: pairingMode(ctx), cli: cliCommand(ctx), csrf: P.randomB64(), passwordSet: !!pw, timeZone: clientTimeZone(req), ...approvalPageBits(ctx) };
 	const send = (status = 200) => {
 		const h: Record<string, string> = P.pageHeaders(nonce, oidcFormOrigins(ctx));
 		h["set-cookie"] = `a2a_device_csrf=${model.csrf}; Path=/device; Secure; HttpOnly; SameSite=Strict; Max-Age=3600`;
@@ -2344,7 +2351,8 @@ async function runTool(ctx: TenantContext, ectx: ExecutionContext, name: string,
 			if (a.all === true) qs.set("all", "1");
 			const tasks = must(await ownerCall(ctx, ectx, "GET", `/owner/inbox${qs.size ? `?${qs}` : ""}`));
 			const pairing = pairingOn(ctx) ? must(await ownerCall(ctx, ectx, "GET", "/owner/pairing")).pending.length : 0;
-			const head = `${tasks.length} task(s)${a.all ? "" : " waiting"}${pairing ? `; ${pairing} pending pairing request(s): see pairing_requests (never approve them yourself)` : ""}. ${UNTRUSTED}`;
+			const manage = pairing ? dashboardUrl(ctx) : "";
+			const head = `${tasks.length} task(s)${a.all ? "" : " waiting"}${pairing ? `; ${pairing} pending pairing request(s): see pairing_requests (never approve them yourself)${manage ? `. Approve or deny at ${manage}` : ""}` : ""}. ${UNTRUSTED}`;
 			return M.toolText(head, tasks);
 		}
 		case "show_task":
@@ -2409,9 +2417,10 @@ async function runTool(ctx: TenantContext, ectx: ExecutionContext, name: string,
 		case "pairing_requests": {
 			if (!pairingOn(ctx)) return "Device-flow pairing is off on this A2A endpoint (PAIRING_APPROVAL=off): there are no pairing requests.";
 			const d = must(await ownerCall(ctx, ectx, "GET", "/owner/pairing"));
-			return M.toolText(`${d.pending.length} pending pairing request(s). Show your human who asks, the code and the link. NEVER approve or deny yourself: your human decides on the link with the approval password. Names and card URLs are claimed by the requester (untrusted).`,
+			const manage = dashboardUrl(ctx);
+			return M.toolText(`${d.pending.length} pending pairing request(s). Show your human who asks, the code and the link.${manage ? ` Approve or deny at ${manage}.` : ""} NEVER approve or deny yourself: your human decides on the link with the approval password. Names and card URLs are claimed by the requester (untrusted).`,
 				d.pending.map((r: Json) => ({ code: r.userCode, clientName: r.clientName, clientId: r.clientId, agentCardUrl: r.agentCardUrl, country: r.country,
-					expiresAt: r.expiresAt, link: r.verificationUriComplete, replacesLabel: r.replacesLabel })));
+					expiresAt: r.expiresAt, link: r.verificationUriComplete, ...(manage ? { manageUrl: manage } : {}), replacesLabel: r.replacesLabel })));
 		}
 		case "send_feedback": {
 			// The owner authorized this client on the consent page. A peer token and the owner token never arrive here.

package/worker/src/pairing.ts

@@ -8,7 +8,7 @@ import { pageStyle } from "./theme.ts";
 export const DEFAULT_CLI = "npx -y a2a-exposed@latest";
 
 export const DEVICE_GRANT = "urn:ietf:params:oauth:grant-type:device_code";
-export const EXPIRES_S = 600; // device / user code lifetime
+export const EXPIRES_S = 3600; // device / user code lifetime (60 minutes)
 export const INTERVAL_S = 5; // minimum polling interval (slow_down adds 5 s each time)
 export const LIMITS = {
 	maxPending: 10, // outstanding (unexpired, undecided) requests, globally: caps approval prompts
@@ -173,12 +173,33 @@ export async function verifyPassword(password: string, rec: PasswordRecord): Pro
 // ------------------------------------------------------------------ /device page (no scripts, no external assets)
 export const esc = (s: unknown) => String(s ?? "").replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]!);
 
-/** "Expires" cell. A live code with under a minute left says so, instead of "0 min". */
-export function expiresText(expiresMs: number, now = Date.now()): string {
+/** "Expires" cell. Clock time in the visitor's time zone, then how long is left. An unknown zone uses UTC. */
+export function expiresText(expiresMs: number, now = Date.now(), timeZone?: string): string {
 	const left = expiresMs - now;
 	if (left <= 0) return "expired";
-	if (left < 60_000) return "less than a minute";
-	return `${Math.round(left / 60000)} min`;
+	const relative = left < 60_000 ? "less than a minute" : `${Math.round(left / 60000)} min`;
+	const { zone, suffix } = clockZone(timeZone);
+	return `${clockTime(expiresMs, zone)}${suffix} (${relative})`;
+}
+
+function clockZone(timeZone: string | undefined): { zone: string; suffix: string } {
+	const zone = (timeZone || "").trim();
+	if (!zone || zone.toUpperCase() === "UTC" || zone === "Etc/UTC" || zone === "Etc/GMT") return { zone: "UTC", suffix: " UTC" };
+	try {
+		new Intl.DateTimeFormat("en-GB", { timeZone: zone }).format(0);
+		return { zone, suffix: "" };
+	} catch {
+		return { zone: "UTC", suffix: " UTC" };
+	}
+}
+
+function clockTime(ms: number, timeZone: string): string {
+	const parts = new Intl.DateTimeFormat("en-GB", {
+		hour: "2-digit", minute: "2-digit", hourCycle: "h23", timeZone,
+	}).formatToParts(new Date(ms));
+	const hour = parts.find((part) => part.type === "hour")?.value ?? "00";
+	const minute = parts.find((part) => part.type === "minute")?.value ?? "00";
+	return `${hour}:${minute}`;
 }
 
 export type PageRequest = { userCode: string; clientName: string; clientId: string; agentCardUrl: string; ip: string; country: string; createdMs: number; expiresMs: number; replacesLabel?: string; tokenLabel?: string };
@@ -196,6 +217,8 @@ export type PageModel = {
 	oidc?: { label: string };
 	/** False hides the password field. Absent means the password field is shown as before. */
 	passwordEnabled?: boolean;
+	/** IANA time zone from the request, when Cloudflare provides one. The expiry clock uses it. */
+	timeZone?: string;
 	/** Set after Approve or Deny: the page shows that result and no code form. */
 	settled?: "approved" | "denied";
 };
@@ -213,7 +236,7 @@ export function devicePage(m: PageModel, nonce: string): string {
 		...(r.clientId && r.clientName && r.clientId !== r.clientName ? [["Alias (claimed)", r.clientId]] : []),
 		["Agent card (claimed)", r.agentCardUrl ? r.agentCardUrl + (cardIsPrivate(r.agentCardUrl) ? " (private network address, e.g. a Tailnet: not publicly reachable, so this A2A endpoint can't check it; informational only)" : "") : "(none given)"],
 		["Requested from", `${[r.ip || "unknown address", r.country].filter(Boolean).join(", ")} (IP address of the machine that asked to connect)`],
-		["Expires", expiresText(r.expiresMs)],
+		["Expires", expiresText(r.expiresMs, Date.now(), m.timeZone)],
 		...(r.replacesLabel ? [["Replaces", `the active token "${r.replacesLabel}" (the requester proved it holds it); approving issues a new token under the same label and the old one stops working`]] : []),
 	] : [];
 	const tokenLabel = r?.tokenLabel || "<label>";

package/worker/src/tenancy.ts

@@ -39,6 +39,8 @@ export const CONFIG_KEYS = [
 	"PAIRING_APPROVAL", "PBKDF2_ITERATIONS",
 	"UPSTREAM_URL", "UPSTREAM_CARD_URL", "UPSTREAM_TOKEN", "UPSTREAM_ACCESS_CLIENT_ID", "UPSTREAM_ACCESS_CLIENT_SECRET",
 	"MCP",
+	/** Optional https URL of this agent's dashboard page. Omitted from pairing output when unset or not https. */
+	"MANAGE_URL",
 ] as const;
 
 export type ConfigKey = (typeof CONFIG_KEYS)[number];
@@ -205,6 +207,19 @@ export async function derivePeerKey(ikm: string, info = PEER_KEY_INFO): Promise<
 	);
 }
 
+/** https dashboard URL with no userinfo, at most 500 characters. Any other value returns "". */
+export function publicManageUrl(value: string | undefined): string {
+	const s = (value || "").trim();
+	if (!s || s.length > 500) return "";
+	try {
+		const u = new URL(s);
+		if (u.protocol !== "https:" || u.username || u.password) return "";
+		return s;
+	} catch {
+		return "";
+	}
+}
+
 function csv(v: string | undefined): string[] {
 	return (v || "").split(",").map((s) => s.trim()).filter(Boolean);
 }
@@ -367,6 +382,7 @@ export class TenantContext implements ConfigFields {
 	readonly UPSTREAM_ACCESS_CLIENT_ID?: string;
 	readonly UPSTREAM_ACCESS_CLIENT_SECRET?: string;
 	readonly MCP?: string;
+	readonly MANAGE_URL?: string;
 
 	/** Self-host only. Never set on a hosted context, so a platform OWNER_TOKEN cannot unlock a tenant. */
 	readonly #ownerToken?: string;

package/worker/src/version.ts

@@ -1,2 +1,2 @@
 /** Inbox build. Keep this equal to `version` in cli/package.json. */
-export const VERSION = "0.8.7";
+export const VERSION = "0.8.8";

package/worker/src/wake.ts

@@ -23,6 +23,8 @@ export type PairingInfo = {
 	agentCardUrl: string;
 	agentCardPrivate?: boolean; // the claimed card is on a private network (Tailnet, LAN): informational, not reachable
 	expiresIn: number;
+	/** Dashboard page for this agent. Present only when MANAGE_URL is an https URL. */
+	manageUrl?: string;
 	replacesLabel?: string; // re-pairing: the requester proved it holds this active token; approval replaces it
 };
 
@@ -78,11 +80,14 @@ export function wakePayload(ev: WakeEvent, cli: string): Record<string, unknown>
 
 /** What the woken agent must do with a pairing request: ask its human, never approve on its own. */
 export function pairingInstructions(p: PairingInfo, cli: string): string {
+	const dash = p.manageUrl ? ` The dashboard page for this request is ${p.manageUrl}.` : "";
 	return p.approval === "human"
 		? `Ask your human; never approve on your own. Show them the code ${p.userCode} and give them this link: ${p.verificationUriComplete} . ` +
-			`They approve there with their approval password, or with \`${cli} pair approve ${p.userCode}\` (the owner token), after checking the code with the other agent's owner. Deny with \`${cli} pair deny ${p.userCode}\`. Details: \`${cli} pair list\`.`
+			`They approve there with their approval password, or with \`${cli} pair approve ${p.userCode}\` (the owner token), after checking the code with the other agent's owner. Deny with \`${cli} pair deny ${p.userCode}\`. Details: \`${cli} pair list\`.` +
+			dash
 		: `Ask your human; never approve on your own. Show them the code ${p.userCode}, who is asking, and the link ${p.verificationUriComplete} . ` +
-			`Only if they say yes, run \`${cli} pair approve ${p.userCode}\`; if they say no (or don't answer), \`${cli} pair deny ${p.userCode}\`.`;
+			`Only if they say yes, run \`${cli} pair approve ${p.userCode}\`; if they say no (or don't answer), \`${cli} pair deny ${p.userCode}\`.` +
+			dash;
 }
 
 function hintFor(ev: WakeEvent, cli: string): string {

package/worker/test/mcp.test.ts

@@ -421,10 +421,34 @@ test("tools: inbox, show_task, history, mark_working, reply (with state), pairin
 	assert.match(pr.content[0].text, /NEVER approve/);
 	assert.match(pr.content[0].text, new RegExp(st.data.user_code));
 	assert.ok(!pr.content[0].text.includes('"ip"'), "requester IPs aren't handed to the model");
-	assert.match((await s.tool(a.access_token, "inbox")).content[0].text, /1 pending pairing request/);
+	const pendingLine = (await s.tool(a.access_token, "inbox")).content[0].text;
+	assert.match(pendingLine, /1 pending pairing request/);
+	assert.equal(pendingLine.includes("manageUrl"), false);
+	assert.equal(pendingLine.includes("Approve or deny at"), false);
 	assert.equal((s.DB.db.prepare("SELECT status FROM device_requests").get() as any).status, "pending");
 });
 
+test("MANAGE_URL is on the MCP inbox line and pairing_requests for a pending request", async (t) => {
+	const pageUrl = "https://example.com/app/agents/test#pairing";
+	const s = setup({ MANAGE_URL: pageUrl });
+	t.after(s.restore);
+	const a = await s.connect();
+	await s.call("POST", "/oauth/device_authorization", { form: { client_name: "Mallory", client_id: "m" } });
+	const inbox = (await s.tool(a.access_token, "inbox")).content[0].text;
+	assert.match(inbox, new RegExp(`1 pending pairing request\\(s\\): see pairing_requests \\(never approve them yourself\\)\\. Approve or deny at ${pageUrl.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`));
+	const listed = (await s.tool(a.access_token, "pairing_requests")).content[0].text;
+	assert.match(listed, new RegExp(`Approve or deny at ${pageUrl.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`));
+	assert.match(listed, new RegExp(`"manageUrl": "${pageUrl.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}"`));
+
+	const off = setup({ MANAGE_URL: "not a url" });
+	t.after(off.restore);
+	const grant = await off.connect();
+	await off.call("POST", "/oauth/device_authorization", { form: { client_name: "Mallory", client_id: "m" } });
+	const quiet = (await off.tool(grant.access_token, "pairing_requests")).content[0].text;
+	assert.equal(quiet.includes("manageUrl"), false);
+	assert.equal(quiet.includes("Approve or deny at"), false);
+});
+
 test("tools: send / poll_outbound through synced peers; each peer's token stays with that peer; tokens never shown", async (t) => {
 	const s = setup(); t.after(s.restore);
 	const a = await s.connect();

package/worker/test/pairing.test.ts

@@ -35,14 +35,16 @@ function setup(over: Record<string, string> = {}) {
 		wakes.push({ url: String(url), body: JSON.parse(init.body) });
 		return new Response("ok");
 	}) as any;
-	const call = async (method: string, path: string, o: { form?: Record<string, string>; json?: any; headers?: Record<string, string>; ip?: string; cookie?: string } = {}) => {
+	const call = async (method: string, path: string, o: { form?: Record<string, string>; json?: any; headers?: Record<string, string>; ip?: string; cookie?: string; cf?: Record<string, unknown> } = {}) => {
 		const headers: Record<string, string> = { "cf-connecting-ip": o.ip || "198.51.100.7", ...(o.headers || {}) };
 		let body: string | undefined;
 		if (o.form) { headers["content-type"] = "application/x-www-form-urlencoded"; body = new URLSearchParams(o.form).toString(); }
 		if (o.json !== undefined) { headers["content-type"] = "application/json"; body = JSON.stringify(o.json); }
 		if (o.cookie) headers.cookie = o.cookie;
 		const pending: Promise<unknown>[] = [];
-		const res = await worker.fetch(new Request(BASE + path, { method, headers, body }) as any, env, { waitUntil: (p: Promise<unknown>) => pending.push(p), passThroughOnException() {} } as any);
+		const req = new Request(BASE + path, { method, headers, body }) as any;
+		if (o.cf) req.cf = o.cf;
+		const res = await worker.fetch(req, env, { waitUntil: (p: Promise<unknown>) => pending.push(p), passThroughOnException() {} } as any);
 		await Promise.allSettled(pending);
 		const text = await res.text();
 		let data: any = text;
@@ -255,7 +257,7 @@ test("human approval: pending, slow_down, page approve with the password, single
 	assert.match(d.user_code, /^[BCDFGHJKLMNPQRSTVWXZ]{4}-[2-9]{4}$/);
 	assert.equal(d.verification_uri, `${BASE}/device`);
 	assert.equal(d.verification_uri_complete, `${BASE}/device?user_code=${d.user_code}`);
-	assert.deepEqual([d.expires_in, d.interval], [600, 5]);
+	assert.deepEqual([d.expires_in, d.interval], [3600, 5]);
 	// the device code is stored hashed only
 	const row: any = s.DB.db.prepare("SELECT * FROM device_requests").get();
 	assert.notEqual(row.device_hash, d.device_code);
@@ -268,6 +270,7 @@ test("human approval: pending, slow_down, page approve with the password, single
 	assert.equal(w.hint, "npx -y a2a-exposed@latest pair list");
 	assert.deepEqual([w.pairing.userCode, w.pairing.verificationUriComplete, w.pairing.approval, w.pairing.clientId], [d.user_code, d.verification_uri_complete, "human", "barry"]);
 	assert.equal(w.pairing.agentCardUrl, "https://barry.example.org/.well-known/agent-card.json");
+	assert.equal("manageUrl" in w.pairing, false);
 	assert.match(w.pairing.instructions, /never approve on your own[\s\S]*give them this link/);
 
 	let p = await s.poll(d.device_code);
@@ -447,7 +450,7 @@ test("labels are deduplicated; denied and expired requests; JSON bodies; bad req
 	assert.equal((await s.poll(c.device_code)).data.error, "invalid_grant", "reported once, then gone");
 
 	const e = (await s.start(undefined, "203.0.113.4")).data;
-	advance(601);
+	advance(P.EXPIRES_S + 1);
 	assert.equal((await s.poll(e.device_code)).data.error, "expired_token");
 	assert.equal((await s.owner("POST", `/owner/pairing/${e.user_code}/approve`)).status, 409);
 	advance(3600);
@@ -500,7 +503,7 @@ test("flood control: requests per IP and outstanding requests are capped (no flo
 	assert.equal(over.status, 429);
 	assert.match(over.data.error_description, /too many pairing requests waiting/);
 	// expiry frees the slots
-	advance(601);
+	advance(P.EXPIRES_S + 1);
 	assert.equal((await s.start(undefined, "198.51.100.99")).status, 200);
 	// the page: code lookups per IP are capped (no enumerating pending requests)
 	for (let i = 0; i < 30; i++) assert.doesNotMatch((await s.call("GET", "/device?user_code=BCDF-2345", { ip: "192.0.2.77" })).text, /Too many code lookups/);
@@ -510,9 +513,9 @@ test("flood control: requests per IP and outstanding requests are capped (no flo
 
 test("pairing wakes: summary for each preset; requester text only where previews are allowed", async () => {
 	const ev: WakeEvent = { contextId: "pairing", taskId: "none", taskIds: [], from: "Barry", preview: "", kind: "pairing_request", publicUrl: BASE,
-		pairing: { userCode: "WDJB-2345", verificationUriComplete: `${BASE}/device?user_code=WDJB-2345`, approval: "human", clientName: "Barry", clientId: "barry", agentCardUrl: "https://barry.example.org/card", expiresIn: 600 } };
+		pairing: { userCode: "WDJB-2345", verificationUriComplete: `${BASE}/device?user_code=WDJB-2345`, approval: "human", clientName: "Barry", clientId: "barry", agentCardUrl: "https://barry.example.org/card", expiresIn: 3600 } };
 	const sum = wakeSummary(ev, "npx -y a2a-exposed@latest");
-	assert.match(sum, /^A2A pairing request: an agent calling itself "Barry" \(claimed card: "https:\/\/barry\.example\.org\/card"\) asks to connect to your A2A endpoint \(code WDJB-2345, expires in 10 minutes\)\./);
+	assert.match(sum, /^A2A pairing request: an agent calling itself "Barry" \(claimed card: "https:\/\/barry\.example\.org\/card"\) asks to connect to your A2A endpoint \(code WDJB-2345, expires in 60 minutes\)\./);
 	assert.match(sum, /never approve on your own\. Show them the code WDJB-2345 and give them this link: https:\/\/agent\.example\.com\/device\?user_code=WDJB-2345/);
 	const agentSum = wakeSummary({ ...ev, pairing: { ...ev.pairing!, approval: "agent" } }, "a2a");
 	assert.match(agentSum, /Only if they say yes, run `a2a pair approve WDJB-2345`; if they say no \(or don't answer\), `a2a pair deny WDJB-2345`/);
@@ -874,10 +877,13 @@ test("owner log lists history without data_json and does not clear a pending wak
 });
 
 test("device page copy: code hint, expiry, token scope, settled result, A2A endpoint", async (t) => {
+	const at = Date.UTC(2026, 9, 16, 14, 32, 0);
+	assert.equal(P.expiresText(at, at - 30_000), "14:32 UTC (less than a minute)");
+	assert.equal(P.expiresText(at, at - 90_000), "14:32 UTC (2 min)");
+	assert.equal(P.expiresText(at, at - 90_000, "America/New_York"), "10:32 (2 min)");
+	assert.equal(P.expiresText(at, at - 90_000, "Not/AZone"), "14:32 UTC (2 min)");
+	assert.equal(P.expiresText(at, at + 1), "expired");
 	const now = Date.now();
-	assert.equal(P.expiresText(now + 30_000, now), "less than a minute");
-	assert.equal(P.expiresText(now + 90_000, now), "2 min");
-	assert.equal(P.expiresText(now - 1, now), "expired");
 	const base = { agentName: "this A2A endpoint", mode: "human" as const, cli: "a2a", csrf: "c".repeat(24), passwordSet: true };
 	const bare = P.devicePage({ ...base, askCode: true }, "n");
 	assert.match(bare, /The connecting agent prints this code when it runs <code>a2a connect &lt;url&gt;<\/code>/);
@@ -888,7 +894,13 @@ test("device page copy: code hint, expiry, token scope, settled result, A2A endp
 	assert.match(page, /so this A2A endpoint can&#39;t check it/);
 	assert.match(page, /send messages and trigger wakes/);
 	assert.match(page, /Message text from peers is untrusted/);
-	assert.match(page, /less than a minute/);
+	assert.match(page, /\d{2}:\d{2} UTC \(less than a minute\)/);
+	const localExpiry = now + 10 * 24 * 3600 * 1000;
+	const localParts = new Intl.DateTimeFormat("en-GB", { hour: "2-digit", minute: "2-digit", hourCycle: "h23", timeZone: "America/New_York" }).formatToParts(new Date(localExpiry));
+	const localClock = `${localParts.find((part) => part.type === "hour")?.value}:${localParts.find((part) => part.type === "minute")?.value}`;
+	const localPage = P.devicePage({ ...base, timeZone: "America/New_York", request: { ...req, expiresMs: localExpiry } }, "n");
+	assert.match(localPage, new RegExp(`${localClock} \\((?:less than a minute|\\d+ min)\\)`));
+	assert.equal(localPage.includes("UTC"), false);
 	assert.match(page, /Revoke the token &lt;label&gt; any time with <code>a2a token revoke &lt;label&gt;<\/code>/);
 	const namedToken = P.devicePage({ ...base, request: { ...req, tokenLabel: "barry" } }, "n");
 	assert.match(namedToken, /Revoke the token barry any time with <code>a2a token revoke barry<\/code>/);
@@ -913,3 +925,33 @@ test("device page copy: code hint, expiry, token scope, settled result, A2A endp
 	const home = await s.call("GET", "/", { headers: { accept: "text/html" } });
 	assert.match(home.text, /Messages are stored for its owner, and the agent is woken/);
 });
+
+test("approval page shows the visitor's clock, and an https MANAGE_URL is on the pairing wake", async (t) => {
+	const pageUrl = "https://example.com/app/agents/test#pairing";
+	const s = setup({ MANAGE_URL: pageUrl });
+	t.after(s.restore);
+	const st = await s.start(undefined, "203.0.113.80");
+	assert.equal(st.status, 200, JSON.stringify(st.data));
+	const row = s.DB.db.prepare("SELECT expires_ms FROM device_requests").get() as { expires_ms: number };
+	const parts = new Intl.DateTimeFormat("en-GB", { hour: "2-digit", minute: "2-digit", hourCycle: "h23", timeZone: "America/New_York" }).formatToParts(new Date(row.expires_ms));
+	const clock = `${parts.find((part) => part.type === "hour")?.value}:${parts.find((part) => part.type === "minute")?.value}`;
+	const page = await s.call("GET", `/device?user_code=${st.data.user_code}`, { cf: { timezone: "America/New_York" }, ip: "203.0.113.80" });
+	assert.match(page.text, new RegExp(`${clock.replace(":", "\\:")} \\(60 min\\)`));
+	assert.equal(page.text.includes(" UTC "), false);
+	const wake = s.wakes[0].body.pairing;
+	assert.equal(wake.manageUrl, pageUrl);
+	assert.equal(wake.expiresIn, 3600);
+	assert.ok(wake.instructions.includes(`The dashboard page for this request is ${pageUrl}`));
+
+	const bare = setup();
+	t.after(bare.restore);
+	const plain = await bare.start(undefined, "203.0.113.81");
+	assert.equal("manageUrl" in bare.wakes[0].body.pairing, false);
+	const utc = await bare.call("GET", `/device?user_code=${plain.data.user_code}`, { ip: "203.0.113.81" });
+	assert.match(utc.text, /\d{2}:\d{2} UTC \(60 min\)/);
+
+	const bad = setup({ MANAGE_URL: "http://example.com/app" });
+	t.after(bad.restore);
+	await bad.start(undefined, "203.0.113.82");
+	assert.equal("manageUrl" in bad.wakes[0].body.pairing, false);
+});

package/worker/test/tenancy.test.ts

@@ -5,7 +5,7 @@ import assert from "node:assert/strict";
 import worker from "../src/index.ts";
 import { sha256 } from "../src/a2a.ts";
 import { openPeerToken, openPeerTokenWithKey, sealPeerToken, sealPeerTokenWithKey } from "../src/mcp.ts";
-import { hostedTenantContext, namespaceForRegion, parseGates, resolveTenant, type WorkerBindings } from "../src/tenancy.ts";
+import { hostedTenantContext, namespaceForRegion, parseGates, publicManageUrl, resolveTenant, type WorkerBindings } from "../src/tenancy.ts";
 import { d1 } from "./d1.ts";
 
 const dummy = { prepare() { throw new Error("storage should not be touched"); } } as any;
@@ -15,6 +15,26 @@ function selfEnv(over: Record<string, unknown> = {}): WorkerBindings {
 	return { DB: dummy, PUBLIC_URL: BASE, OWNER_TOKEN: "owner-secret", ...over } as WorkerBindings;
 }
 
+test("publicManageUrl keeps an https dashboard page and drops anything else", () => {
+	const page = "https://example.com/app/agents/test#pairing";
+	assert.equal(publicManageUrl(page), page);
+	assert.equal(publicManageUrl(`  ${page}  `), page);
+	assert.equal(publicManageUrl(""), "");
+	assert.equal(publicManageUrl(undefined), "");
+	assert.equal(publicManageUrl("http://example.com/app"), "");
+	assert.equal(publicManageUrl("https://user:pw@example.com/app"), "");
+	assert.equal(resolveTenant(selfEnv({ MANAGE_URL: page })).MANAGE_URL, page);
+	assert.equal(resolveTenant(selfEnv()).MANAGE_URL, undefined);
+	const hosted = hostedTenantContext(selfEnv({ TENANCY: "host", MANAGE_URL: "https://platform.example/other" }), {
+		id: "ten_a", db: dummy, publicUrl: BASE, config: { MANAGE_URL: page },
+	});
+	assert.equal(hosted.MANAGE_URL, page);
+	const hostedUnset = hostedTenantContext(selfEnv({ TENANCY: "host", MANAGE_URL: page }), {
+		id: "ten_a", db: dummy, publicUrl: BASE,
+	});
+	assert.equal(hostedUnset.MANAGE_URL, undefined);
+});
+
 test("gates: unset is single-tenant and every reserved gate is off", () => {
 	const g = parseGates({ DB: dummy } as WorkerBindings).gates;
 	assert.equal(g.tenancy, "single");