a2a-exposed 0.4.1 → 0.6.0

package/README.md

@@ -3,14 +3,13 @@
 Command-line companion for [a2a-exposed](https://github.com/telegraphic-dev/a2a-exposed). It gives any AI agent a public A2A endpoint: a Cloudflare Worker inbox plus a wake webhook.
 
 ```bash
-npm i -g a2a-exposed          # or one-off: npx -y a2a-exposed@latest --help
-a2a-exposed --help
+npx -y a2a-exposed@latest --help      # no install needed; @latest always runs the newest release
 ```
 
-The agent skills (`npx --yes skills add telegraphic-dev/a2a-exposed`) document the workflows; they do not install this CLI.
+Optional speed-up on your own machine: `npm i -g a2a-exposed@latest`, then `a2a-exposed <command>` (re-run the install to upgrade; the CLI prints a notice when a newer version is out). Agent sandboxes often block global installs as untrusted code, so docs, skills and wake hints always use the npx form. The agent skills (`npx -y skills add telegraphic-dev/a2a-exposed`, into the current project) document the workflows; they do not install this CLI.
 
 - Node 22.18+ and zero dependencies. `init` installs Cloudflare's `cf` CLI into the Worker folder and uses that; you only need a one-time login (`npx cf auth login --no-browser`). No domain? Omit `--hostname` and `init` deploys to `https://<worker>.<account-subdomain>.workers.dev` (`--workers-dev-subdomain <name>` registers the account subdomain if missing).
-- **Setup:** `init`, `deploy`, `wake set|unset|test|preview|fingerprint`, `tunnel create|status|rm` (secure Cloudflare Tunnel + Access for local-only webhooks; needs any zone on the account, the inbox can be on workers.dev), `status` (read-only setup check with a next step), `url`, `config`. Use `--cli-command` to set the command shown in wake hints (default `npx a2a-exposed`; e.g. a `node <checkout>/cli/bin/a2a-exposed.mjs` path for development).
+- **Setup:** `init`, `deploy`, `wake set|unset|test|preview|fingerprint`, `tunnel create|status|rm` (secure Cloudflare Tunnel + Access for local-only webhooks; needs any zone on the account, the inbox can be on workers.dev), `status` (read-only setup check with a next step), `url`, `config`. Use `--cli-command` to set the command shown in wake hints (default `npx -y a2a-exposed@latest`; e.g. a `node <checkout>/cli/bin/a2a-exposed.mjs` path for development).
 - **Inbox:** `inbox`, `show`, `working`, `reply`, `history`, `contexts`
 - **Pairing (OAuth 2.0 device flow, RFC 8628):** `connect <url>` (ask another inbox for a token; its owner approves), `pair set-password|list|approve|deny` (approve agents that connect to you; human approval by default)
 - **Peer tokens:** `token issue|list|revoke|rotate` (manual fallback; `list` also shows tokens created by pairing)

package/lib/a2a.mjs

@@ -3,6 +3,10 @@ import crypto from "node:crypto";
 
 export const ID_RE = /^[A-Za-z0-9._:-]{1,128}$/;
 
+/** The one way docs, hints and CLI output tell people (and agents) to run the CLI: npx, always the latest release, no
+ *  global install (agent sandboxes block global installs as untrusted code). A global install is an optional speed-up. */
+export const CLI = "npx -y a2a-exposed@latest";
+
 export class CliError extends Error {}
 export const die = (msg) => { throw new CliError(msg); };
 
@@ -178,8 +182,8 @@ export async function rpc(url, version, token, method03, method1, params, peer =
 		const who = peer && peer.alias ? `peer "${peer.alias}"` : new URL(url).origin;
 		const base = (peer && peer.base) || new URL(url).origin;
 		die(token
-			? `${who} rejected our token (HTTP 401: revoked, rotated, or never valid there). Re-pair: a2a-exposed connect ${base}${peer && peer.alias ? ` --alias ${peer.alias}` : ""} (its owner approves), or ask its owner for a new token`
-			: `${who} needs a token (HTTP 401): a2a-exposed connect ${base}${peer && peer.alias ? ` --alias ${peer.alias}` : ""} (its owner approves)`);
+			? `${who} rejected our token (HTTP 401: revoked, rotated, or never valid there). Re-pair: ${CLI} connect ${base}${peer && peer.alias ? ` --alias ${peer.alias}` : ""} (its owner approves), or ask its owner for a new token`
+			: `${who} needs a token (HTTP 401): ${CLI} connect ${base}${peer && peer.alias ? ` --alias ${peer.alias}` : ""} (its owner approves)`);
 	}
 	if (status !== 200 || !data || typeof data !== "object" || "error" in data)
 		die(`peer returned ${data && typeof data === "object" && data.error ? `JSON-RPC error ${describeHttp(status, data).replace(/^HTTP \d+: /, "")} (HTTP ${status})` : describeHttp(status, data)}`);

package/lib/commands.mjs

@@ -1,25 +1,25 @@
 // Day-to-day commands: inbox / reply / history (owner API) and outbound send / poll.
 import fs from "node:fs";
 import * as C from "./config.mjs";
-import { checkId, describeHttp, die, fetchCard, httpJson, newId, pickEndpoint, plainState, randomToken, rpc, textOf } from "./a2a.mjs";
+import { CLI, checkId, describeHttp, die, fetchCard, httpJson, newId, pickEndpoint, plainState, randomToken, rpc, textOf } from "./a2a.mjs";
 
 const q = encodeURIComponent;
 const out = (obj) => console.log(JSON.stringify(obj, null, 2));
 export const baseUrl = () => C.get("A2A_BASE_URL").replace(/\/$/, "");
 
-export async function owner(method, path, body) {
+export async function owner(method, path, body, timeout) {
 	const base = baseUrl(), tok = C.get("A2A_OWNER_TOKEN");
-	if (!base || !tok) die(`A2A_BASE_URL / A2A_OWNER_TOKEN missing (run \`a2a-exposed init\` or edit ${C.CONFIG_FILE})`);
-	const { status, data } = await httpJson(base + path, { method, body, headers: { authorization: `Bearer ${tok}` } });
+	if (!base || !tok) die(`A2A_BASE_URL / A2A_OWNER_TOKEN missing (run \`${CLI} init\` or edit ${C.CONFIG_FILE})`);
+	const { status, data } = await httpJson(base + path, { method, body, headers: { authorization: `Bearer ${tok}` }, timeout });
 	if (status < 200 || status >= 300) die(`worker ${method} ${path} -> ${describeHttp(status, data)}`);
 	return data;
 }
 
 /** Owner API call that returns { status, data } instead of dying, so callers can explain errors themselves. */
-export async function ownerTry(method, path, body) {
+export async function ownerTry(method, path, body, timeout) {
 	const base = baseUrl(), tok = C.get("A2A_OWNER_TOKEN");
-	if (!base || !tok) die(`A2A_BASE_URL / A2A_OWNER_TOKEN missing (run \`a2a-exposed init\` or edit ${C.CONFIG_FILE})`);
-	return httpJson(base + path, { method, body, headers: { authorization: `Bearer ${tok}` } });
+	if (!base || !tok) die(`A2A_BASE_URL / A2A_OWNER_TOKEN missing (run \`${CLI} init\` or edit ${C.CONFIG_FILE})`);
+	return httpJson(base + path, { method, body, headers: { authorization: `Bearer ${tok}` }, ...(timeout ? { timeout } : {}) });
 }
 
 function printPush(res) {
@@ -62,7 +62,7 @@ export async function inbox(o) {
 	}
 }
 
-const PAIRING_NOTE = "Tell your human who is asking, the code and the link (details: a2a-exposed pair list). Never approve on your own: in human mode they approve on the link with their approval password; in agent mode run `pair approve <code>` only after they say yes.";
+const PAIRING_NOTE = `Tell your human who is asking, the code and the link (details: ${CLI} pair list). Never approve on your own: in human mode they approve on the link with their approval password; in agent mode run \`pair approve <code>\` only after they say yes.`;
 
 export const show = async (id) => out(await owner("GET", `/owner/tasks/${q(id)}`));
 
@@ -101,6 +101,11 @@ export async function token(action, label, o) {
 			const via = r.source === "pairing" ? `\tvia pairing: code ${r.user_code || "?"}${r.client_name ? `, ${JSON.stringify(r.client_name)}` : ""}` : "";
 			console.log(`${r.label}\tcreated=${r.created_at}\t${r.revoked_at ? "REVOKED " + r.revoked_at : "active"}${via}`);
 		}
+		// MCP connectors (Worker 0.5+): their own tokens, listed and revoked by label like peer tokens
+		const m = await ownerTry("GET", "/owner/mcp").catch(() => null);
+		if (m && m.status === 200 && m.data && Array.isArray(m.data.grants))
+			for (const g of m.data.grants)
+				console.log(`${g.label}\tcreated=${g.created_at}\t${g.revoked_at ? "REVOKED " + g.revoked_at : "active"}\tMCP connector: ${JSON.stringify(g.client_name || "?")} -> ${g.redirect_host}${g.last_used_at ? `, last used ${g.last_used_at}` : ""}`);
 		return;
 	}
 	if (!label) die("label required");
@@ -118,8 +123,16 @@ export async function token(action, label, o) {
 			if (o.json) return out({ revoked: true, label });
 			return console.log(`revoked ${label}: its token gets HTTP 401 from now on`);
 		}
+		if (r.status === 404) {
+			// not a peer token: maybe an MCP connector
+			const m = await ownerTry("DELETE", `/owner/mcp/${q(label)}`).catch(() => null);
+			if (m && m.status === 200 && m.data && m.data.revoked === true) {
+				if (o.json) return out({ revoked: true, label, kind: "mcp" });
+				return console.log(`revoked ${label}: that MCP connector gets HTTP 401 from now on (remove it in the client, or reconnect to approve it again)`);
+			}
+		}
 		if (r.status === 404 || (r.status === 200 && r.data && r.data.revoked === false))
-			die((r.data && r.data.error) || `no active token with label ${label} (see: a2a-exposed token list)`);
+			die((r.data && r.data.error) || `no active token with label ${label} (see: ${CLI} token list)`);
 		die(`could not revoke ${label}: ${describeHttp(r.status, r.data)}`);
 	}
 	die(`unknown token action ${action} (issue|list|revoke|rotate)`);
@@ -154,10 +167,38 @@ function resolvePeer(to) {
 		for (const [alias, pe] of Object.entries(peers)) if (pe.url.replace(/\/$/, "") === to.replace(/\/$/, "")) return resolvePeer(alias);
 		return [to, to.replace(/\/$/, ""), peerToken("A2A_PEER_TOKEN")];
 	}
-	die(`unknown peer alias ${JSON.stringify(to)} (see: a2a-exposed peers list)`);
+	die(`unknown peer alias ${JSON.stringify(to)} (see: ${CLI} peers list)`);
+}
+
+/** peers sync [alias...]: upload outbound peers (URL + token, encrypted on the Worker with a key derived from the owner
+ *  token) so the MCP connector's send / poll_outbound tools can reach them. peers unsync <alias>: remove one. */
+async function peersRemote(sub, args) {
+	if (sub === "unsync") {
+		if (!args.length) die("usage: peers unsync <alias>...");
+		for (const alias of args) {
+			const r = await ownerTry("DELETE", `/owner/outbound-peers/${q(alias)}`);
+			if (r.status !== 200) die((r.data && r.data.error) || `could not unsync ${alias}: ${describeHttp(r.status, r.data)}`);
+			console.log(`unsynced ${alias}: the connector can no longer send to it`);
+		}
+		return;
+	}
+	const all = C.loadPeers();
+	const list = args.length ? args : Object.keys(all);
+	if (!list.length) die(`no peers to sync: add one first (${CLI} connect <url> or peers add)`);
+	for (const alias of list) {
+		const pe = all[alias];
+		if (!pe) die(`unknown peer alias ${JSON.stringify(alias)} (see: ${CLI} peers list)`);
+		const tok = peerToken(pe.token_env);
+		const r = await ownerTry("PUT", `/owner/outbound-peers/${q(alias)}`, { url: pe.url.replace(/\/$/, ""), ...(tok ? { token: tok } : {}) });
+		if (r.status === 404) die(`this Worker has no MCP support yet: redeploy (${CLI} deploy) and try again`);
+		if (r.status !== 200) die(`could not sync ${alias}: ${(r.data && r.data.error) || describeHttp(r.status, r.data)}`);
+		console.log(`synced ${alias}\t${pe.url}\t${tok ? "token stored encrypted on the Worker" : "no token"}`);
+	}
+	console.error("# the MCP connector's send tool can now reach these peers; re-run after connect / token changes or an owner-token rotation");
 }
 
 export function peers(sub, args, o) {
+	if (sub === "sync" || sub === "unsync") return peersRemote(sub, args);
 	const all = C.loadPeers();
 	if (sub === "add") {
 		const [alias, url] = args;
@@ -192,7 +233,7 @@ export function peers(sub, args, o) {
 		const inUse = new Set(Object.values(all).map((x) => x.token_env));
 		const reserved = (k) => /^(A2A_|CLOUDFLARE_|WAKE_|CF_PROFILE$)/.test(k);
 		const drop = [...vars].filter((k) => !inUse.has(k) && !reserved(k) && k in C.fileConfig());
-		if (!pe && !drop.length) die(`unknown peer alias ${JSON.stringify(alias)} (see: a2a-exposed peers list)`);
+		if (!pe && !drop.length) die(`unknown peer alias ${JSON.stringify(alias)} (see: ${CLI} peers list)`);
 		if (pe) C.savePeers(all);
 		if (drop.length) C.saveConfig(Object.fromEntries(drop.map((k) => [k, null])));
 		return console.log(`removed ${alias}${drop.length ? ` (and ${drop.join(", ")} from ${C.CONFIG_FILE})` : ""}`);
@@ -237,7 +278,7 @@ export async function send(o) {
 	if (tid) await owner("POST", "/owner/outbound", { taskId: tid, contextId: ctx, peer: alias, endpoint: url, protocol: version, pushToken, task: obj });
 	else if (obj && obj.parts) await logHistory(ctx, { dir: "in", peer: alias, role: "agent", event: "direct_message", text: textOf(obj) });
 	out(obj);
-	if (tid) console.error(`# task ${tid}: ${plainState(obj)}  (check: a2a-exposed poll --to ${alias} ${tid})`);
+	if (tid) console.error(`# task ${tid}: ${plainState(obj)}  (check: ${CLI} poll --to ${alias} ${tid})`);
 }
 
 export async function poll(taskId, o) {
@@ -260,3 +301,12 @@ export async function poll(taskId, o) {
 }
 
 export const outbound = async (id) => out(await owner("GET", `/owner/outbound/${q(id)}`));
+
+// ---------------------------------------------------------------- export
+/** JSON dump on stdout. `--sql` prints the same tables as SQL text. */
+export async function exportInbox(o) {
+	const path = o.sql ? "/owner/export?format=sql" : "/owner/export";
+	const data = await owner("GET", path, undefined, 120000);
+	if (o.sql) return console.log(typeof data === "string" ? data.replace(/\n$/, "") : JSON.stringify(data));
+	return out(data);
+}

package/lib/deploy.mjs

@@ -5,12 +5,25 @@ import path from "node:path";
 import { spawn, spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import * as C from "./config.mjs";
-import { cardUrlProblem, cfErrorCode, die, fetchUpstreamCard, fingerprint, httpJson, randomToken, upstreamAuth, upstreamCardUrlProblem, upstreamUrlProblem } from "./a2a.mjs";
+import { CLI, cardUrlProblem, cfErrorCode, die, fetchUpstreamCard, fingerprint, httpJson, randomToken, upstreamAuth, upstreamCardUrlProblem, upstreamUrlProblem } from "./a2a.mjs";
 import { owner, ownerTry } from "./commands.mjs";
 import { readHidden } from "./pair.mjs";
 import * as WD from "./workersdev.mjs";
 
 const PKG_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+/** Each Claude Code routine fire is a new cloud session: a 2xx only means a session started. */
+export const CLAUDE_CODE_NOTE = [
+	"note (claude-code): each fire starts a NEW cloud session, which sees only what the routine provides.",
+	"  Simplest: add this inbox as a connector at claude.ai/settings/connectors (URL: <your Worker URL>/mcp, approve with",
+	"  your approval password) and keep it enabled on the routine; the session then uses its tools, no CLI or token needed.",
+	"  Without the connector (CLI fallback), check that",
+	"  - the repo with the committed skills (.claude/skills/) is a routine source and the skills are on its default branch,",
+	"  - A2A_BASE_URL and A2A_OWNER_TOKEN are set on the routine's cloud environment (not only in this session),",
+	"  - the environment's network access allows this Worker's hostname,",
+	"  - the routine prompt tells Claude to act on the routine-fire-payload block.",
+	"  Then open the new session from the routine's runs and confirm it ran the inbox command without errors.",
+].join("\n");
+
 const PRESETS = ["grok-bot", "claude-code", "openclaw-wake", "openclaw-agent", "hermes", "generic"];
 // WAKE_ACCESS_*: Cloudflare Access service token for a wake URL behind Access (set by `tunnel create`, or exported
 // by hand for your own Access-protected endpoint)
@@ -18,7 +31,9 @@ export const WAKE_SECRETS = ["WAKE_WEBHOOK_URL", "WAKE_WEBHOOK_KEY", "WAKE_HMAC_
 // Proxy / expose mode (--upstream): the one credential the façade presents to the private upstream (Bearer), and the
 // Cloudflare Access service token for the upstream's tunnel hostname. Read from the environment only (never argv).
 export const UPSTREAM_SECRETS = ["UPSTREAM_TOKEN", "UPSTREAM_ACCESS_CLIENT_ID", "UPSTREAM_ACCESS_CLIENT_SECRET"];
-const DEPLOY_SECRETS = [...WAKE_SECRETS, ...UPSTREAM_SECRETS];
+/** OpenID Connect client secret for approval. Environment only; never config.env. */
+export const OIDC_SECRETS = ["APPROVAL_OIDC_CLIENT_SECRET"];
+const DEPLOY_SECRETS = [...WAKE_SECRETS, ...UPSTREAM_SECRETS, ...OIDC_SECRETS];
 
 // Non-secret deploy settings persisted in config.env and passed to cloudflare.config.ts as env vars.
 const DEPLOY_KEYS = [
@@ -27,8 +42,9 @@ const DEPLOY_KEYS = [
 	"A2A_PROVIDER_ORGANIZATION", "A2A_PROVIDER_URL", "A2A_DOCUMENTATION_URL",
 	"WAKE_PRESET", "WAKE_AGENT_ID", "WAKE_KEY_HEADER", "WAKE_KEY_PREFIX", "WAKE_BODY_TEMPLATE", "WAKE_CLI_COMMAND",
 	"WAKE_DEBOUNCE_SECONDS", "WAKE_MAX_PER_HOUR", "A2A_MAX_BODY", "A2A_RATE_PER_MIN", "A2A_ENABLE_CRON",
-	"A2A_WORKERS_DEV_SUBDOMAIN", "A2A_RETIRED_HOSTNAMES", "PAIRING_APPROVAL", "A2A_PBKDF2_ITERATIONS", "A2A_WORKERS_LOGS",
+	"A2A_WORKERS_DEV_SUBDOMAIN", "A2A_RETIRED_HOSTNAMES", "PAIRING_APPROVAL", "A2A_PBKDF2_ITERATIONS", "A2A_WORKERS_LOGS", "A2A_MCP",
 	"A2A_UPSTREAM_URL", "A2A_UPSTREAM_CARD_URL",
+	"APPROVAL_OIDC_ISSUER", "APPROVAL_OIDC_CLIENT_ID", "APPROVAL_OIDC_ALLOWED_SUBJECTS", "APPROVAL_METHODS",
 ];
 // init/deploy flag -> config key
 const FLAG_KEYS = {
@@ -37,7 +53,7 @@ const FLAG_KEYS = {
 	"provider-organization": "A2A_PROVIDER_ORGANIZATION", "provider-url": "A2A_PROVIDER_URL",
 	preset: "WAKE_PRESET", "agent-id": "WAKE_AGENT_ID", "key-header": "WAKE_KEY_HEADER", "key-prefix": "WAKE_KEY_PREFIX",
 	"body-template": "WAKE_BODY_TEMPLATE", "cli-command": "WAKE_CLI_COMMAND", debounce: "WAKE_DEBOUNCE_SECONDS", "max-per-hour": "WAKE_MAX_PER_HOUR",
-	"pairing-approval": "PAIRING_APPROVAL", "pbkdf2-iterations": "A2A_PBKDF2_ITERATIONS", "workers-logs": "A2A_WORKERS_LOGS",
+	"pairing-approval": "PAIRING_APPROVAL", "pbkdf2-iterations": "A2A_PBKDF2_ITERATIONS", "workers-logs": "A2A_WORKERS_LOGS", mcp: "A2A_MCP",
 	upstream: "A2A_UPSTREAM_URL", "upstream-card-url": "A2A_UPSTREAM_CARD_URL",
 };
 export const PAIRING_MODES = ["human", "agent", "off"];
@@ -55,7 +71,7 @@ export const workerDir = (o) => path.resolve(o.dir || C.get("A2A_WORKER_DIR") ||
 /** How to get Node 22.18+ (printed by the version check; the setup skill says the same). */
 export const NODE_HELP = `How to get Node 22 (any one; no root needed):
   mise (recommended; the agent skill: npx skills add telegraphic-dev/mise-skill):
-    one command:   mise exec node@22 -- npx a2a-exposed <command>
+    one command:   mise exec node@22 -- npx -y a2a-exposed@latest <command>
     this project:  mise use node@22   (then node/npx are Node 22 in this directory)
   nvm:   nvm install 22 && nvm use 22
   fnm:   fnm install 22 && fnm use 22
@@ -151,7 +167,7 @@ export function wakeSecretsFromEnv() {
 /** Secrets init/deploy upload when exported: the wake secrets plus, for proxy mode, the upstream credentials. */
 export function deploySecretsFromEnv() {
 	const s = wakeSecretsFromEnv();
-	for (const k of UPSTREAM_SECRETS) if (process.env[k]) s[k] = process.env[k];
+	for (const k of [...UPSTREAM_SECRETS, ...OIDC_SECRETS]) if (process.env[k]) s[k] = process.env[k];
 	return s;
 }
 
@@ -194,6 +210,10 @@ function applyFlags(o) {
 			die("--pbkdf2-iterations must be an integer from 50000 to 100000 (default 100000, the Workers maximum; lower it only if /device approvals hit Cloudflare error 1102, the CPU limit)");
 		upd.A2A_PBKDF2_ITERATIONS = String(n);
 	}
+	if (upd.A2A_MCP !== undefined) {
+		if (!["on", "off"].includes(upd.A2A_MCP)) die("--mcp must be on or off (the remote MCP server at /mcp that Claude and other MCP clients add as a connector; default on)");
+		upd.A2A_MCP = upd.A2A_MCP === "off" ? "off" : null;
+	}
 	if (upd.A2A_WORKERS_LOGS !== undefined) {
 		if (!["on", "off"].includes(upd.A2A_WORKERS_LOGS)) die("--workers-logs must be on or off (Cloudflare Workers Logs: persisted, searchable Worker logs; query strings redacted)");
 		upd.A2A_WORKERS_LOGS = upd.A2A_WORKERS_LOGS === "on" ? "1" : null;
@@ -229,7 +249,7 @@ function applyFlags(o) {
 function reportSwitch(sw) {
 	if (!sw) return;
 	const to = C.fileConfig().A2A_BASE_URL || publicBase();
-	const card = to ? `${to}/.well-known/agent-card.json` : "(see `a2a-exposed url`)";
+	const card = to ? `${to}/.well-known/agent-card.json` : `(see \`${CLI} url\`)`;
 	console.error(`\nnote: the public URL moved${sw.from ? ` from ${sw.from}` : ""} to ${to || "workers.dev"}.`);
 	if (sw.fromHost) {
 		console.error(`  ${sw.fromHost} no longer serves this agent: its agent card redirects (301) to the new one and every other request gets 410 Gone.`);
@@ -272,9 +292,9 @@ async function verifyDeployedCard(base) {
 	if (justRegistered) step("waiting for the new workers.dev subdomain to resolve (usually 1-5 minutes)");
 	const r = await verifyCard(base, { tries, intervalMs: Number(process.env.A2A_VERIFY_INTERVAL_MS || 5000),
 		onWait: (why) => step(`agent card not served yet (${why}); a new deployment takes up to ~30 s to propagate, waiting`) });
-	if (r.ok && r.problem) return console.error(`warning: the agent card at ${base}/.well-known/agent-card.json does not point peers at this deployment: ${r.problem}. Check with: a2a-exposed status`);
+	if (r.ok && r.problem) return console.error(`warning: the agent card at ${base}/.well-known/agent-card.json does not point peers at this deployment: ${r.problem}. Check with: ${CLI} status`);
 	if (r.ok) return console.error(`agent card OK: ${r.name} (${base}/.well-known/agent-card.json)`);
-	console.error(`warning: agent card not reachable yet at ${base} (${r.lastError || "no answer"}); ${C.get("A2A_HOSTNAME") ? "a new custom domain" : "a new workers.dev deployment or subdomain"} can take a few minutes. Check again with: a2a-exposed status`);
+	console.error(`warning: agent card not reachable yet at ${base} (${r.lastError || "no answer"}); ${C.get("A2A_HOSTNAME") ? "a new custom domain" : "a new workers.dev deployment or subdomain"} can take a few minutes. Check again with: ${CLI} status`);
 }
 
 /** Apply D1 migrations quietly: cf prints a bare JSON array (often `[]`) when stdout is not a TTY. */
@@ -333,7 +353,7 @@ async function deployAndLearn(dir, secrets, o) {
 	if (sub && o["workers-dev-subdomain"] && sub !== o["workers-dev-subdomain"])
 		console.error(`note: the account already has the workers.dev subdomain "${sub}"; using it (--workers-dev-subdomain ignored)`);
 	if (sub && sub !== baked()) C.saveConfig({ A2A_WORKERS_DEV_SUBDOMAIN: sub });
-	if (!baked()) return console.error("warning: could not find the workers.dev URL in cf's output; the Worker uses the request origin meanwhile. Check the URL in the dashboard and re-run `a2a-exposed deploy`.");
+	if (!baked()) return console.error(`warning: could not find the workers.dev URL in cf's output; the Worker uses the request origin meanwhile. Check the URL in the dashboard and re-run \`${CLI} deploy\`.`);
 	C.saveConfig({ A2A_BASE_URL: publicBase() });
 	if (baked() !== deployedWith) {
 		step(`redeploying once so the agent card advertises ${publicBase()}`);
@@ -411,7 +431,7 @@ export async function init(o) {
 	console.log(base);
 	reportSwitch(switched);
 	proxyNote(secrets);
-	console.error(`config saved to ${C.CONFIG_FILE} (chmod 600). Next: a2a-exposed status (shows the next setup step)`);
+	console.error(`config saved to ${C.CONFIG_FILE} (chmod 600). Next: ${CLI} status (shows the next setup step)`);
 }
 
 /** Proxy / expose mode reminder after a deploy (the upstream credentials are secrets: only their names are shown). */
@@ -420,7 +440,7 @@ function proxyNote(secrets = {}) {
 	if (!up) return;
 	const sent = UPSTREAM_SECRETS.filter((k) => k in secrets);
 	console.error(`proxy mode: authenticated A2A calls are forwarded to ${up}; the public card is the upstream's, rewritten to this deployment's URL.` +
-		` Upstream secrets uploaded now: ${sent.join(", ") || "none (existing ones kept)"}. Check the whole path (Access, the agent's bearer check) with: a2a-exposed status`);
+		` Upstream secrets uploaded now: ${sent.join(", ") || "none (existing ones kept)"}. Check the whole path (Access, the agent's bearer check) with: ${CLI} status`);
 }
 
 /** stdin and stderr are a terminal (a human at the keyboard), and not CI: only then may setup prompt. */
@@ -480,18 +500,18 @@ export async function upstreamTokenCheck(o, { upstreamChanged = false } = {}) {
 		if (t) { C.saveConfig({ A2A_UPSTREAM_NO_TOKEN: null }); return { UPSTREAM_TOKEN: t }; }
 		if (auth.bearer) die("no UPSTREAM_TOKEN given, but the upstream card asks for one: peers' calls would fail with HTTP 502. Re-run and enter it, or pass --no-upstream-token if the agent really accepts calls without it");
 		C.saveConfig({ A2A_UPSTREAM_NO_TOKEN: "1" });
-		console.error("note: deploying without an upstream bearer token (saved; check the whole path with `a2a-exposed status`)");
+		console.error(`note: deploying without an upstream bearer token (saved; check the whole path with \`${CLI} status\`)`);
 		return {};
 	}
 	die(`${why}, and no UPSTREAM_TOKEN is set. ${access}, so without it every peer call fails with HTTP 502.\n` +
-		"  Provide it (never as an argument): `read -rs UPSTREAM_TOKEN && export UPSTREAM_TOKEN`, then re-run; or pipe it: <command that prints the token> | a2a-exposed " +
+		`  Provide it (never as an argument): \`read -rs UPSTREAM_TOKEN && export UPSTREAM_TOKEN\`, then re-run; or pipe it: <command that prints the token> | ${CLI} ` +
 		`${C.get("A2A_D1_ID") ? "deploy" : "init ..."} --upstream-token-stdin\n` +
 		"  The agent needs no bearer token? Re-run with --no-upstream-token (saved for later deploys).");
 }
 
 export async function deploy(o) {
 	checkNode();
-	if (!C.get("A2A_D1_ID")) die("no saved deployment; run `a2a-exposed init` first");
+	if (!C.get("A2A_D1_ID")) die(`no saved deployment; run \`${CLI} init\` first`);
 	// init saves A2A_WORKER_NAME before it creates the D1 database, so a saved D1 without a name is a hand-edited config:
 	// refuse rather than guess, so a redeploy never creates a second Worker next to the one this config deployed.
 	if (!C.get("A2A_WORKER_NAME") && o["worker-name"] === undefined)
@@ -529,7 +549,7 @@ function guardTunnelUrl() {
 	if (!th || !url) return;
 	let host = "";
 	try { host = new URL(url).host; } catch { /* invalid URL: reported elsewhere */ }
-	if (host !== th) die(`this deployment wakes through the tunnel https://${th} (tunnel create); unset WAKE_WEBHOOK_URL, or run \`a2a-exposed tunnel rm\` first`);
+	if (host !== th) die(`this deployment wakes through the tunnel https://${th} (tunnel create); unset WAKE_WEBHOOK_URL, or run \`${CLI} tunnel rm\` first`);
 }
 
 export async function wake(sub, o) {
@@ -545,7 +565,7 @@ export async function wake(sub, o) {
 		const local = localFingerprints(), remote = r.fingerprints || {};
 		for (const [k, v] of Object.entries(local)) {
 			if (!v) continue;
-			if (!r.fingerprints) { console.error("# this Worker predates fingerprints; redeploy (a2a-exposed deploy) to compare"); break; }
+			if (!r.fingerprints) { console.error(`# this Worker predates fingerprints; redeploy (${CLI} deploy) to compare`); break; }
 			console.error(`# ${k}: local ${v} vs uploaded ${remote[k] || "(unset)"} -> ${v === remote[k] ? "match" : "DIFFERENT"}`);
 		}
 		return;
@@ -553,9 +573,10 @@ export async function wake(sub, o) {
 	if (sub === "test") {
 		const r = await owner("POST", "/owner/wake/test", {});
 		if (r.configured === false || r.info === "WAKE_WEBHOOK_URL unset")
-			die("no wake webhook configured on the Worker: export WAKE_WEBHOOK_URL (and WAKE_WEBHOOK_KEY or WAKE_HMAC_SECRET), then run `a2a-exposed wake set` first (or use polling)");
+			die(`no wake webhook configured on the Worker: export WAKE_WEBHOOK_URL (and WAKE_WEBHOOK_KEY or WAKE_HMAC_SECRET), then run \`${CLI} wake set\` first (or use polling)`);
 		console.log(JSON.stringify(r, null, 2));
 		if (!(r.status >= 200 && r.status < 300)) process.exitCode = 1;
+		else if (C.get("WAKE_PRESET") === "claude-code") console.error(CLAUDE_CODE_NOTE);
 		return;
 	}
 	if (sub === "set") {
@@ -564,7 +585,9 @@ export async function wake(sub, o) {
 		if (!Object.keys(secrets).length && !DEPLOY_FLAGS.some((f) => o[f] !== undefined))
 			die("nothing to set: export WAKE_WEBHOOK_URL / WAKE_WEBHOOK_KEY / WAKE_HMAC_SECRET and/or pass --preset etc.");
 		await deploy(o); // wake set = save settings + upload secrets + redeploy, in one step
-		return console.error("wake settings deployed. Next: a2a-exposed wake preview, then a2a-exposed wake test");
+		console.error(`wake settings deployed. Next: ${CLI} wake preview, then ${CLI} wake test`);
+		if (C.get("WAKE_PRESET") === "claude-code") console.error(CLAUDE_CODE_NOTE);
+		return;
 	}
 	if (sub === "unset") {
 		const dir = workerDir(o), name = workerName();

package/lib/main.mjs

@@ -1,6 +1,6 @@
 import { parseArgs } from "node:util";
 import fs from "node:fs";
-import { CliError } from "./a2a.mjs";
+import { CLI, CliError } from "./a2a.mjs";
 import * as C from "./config.mjs";
 import * as cmd from "./commands.mjs";
 import * as dep from "./deploy.mjs";
@@ -13,16 +13,17 @@ const VERSION = JSON.parse(fs.readFileSync(new URL("../package.json", import.met
 
 const HELP = `a2a-exposed ${VERSION} - public A2A endpoint for any AI agent (Cloudflare Worker inbox + wake webhook)
 
-Usage: a2a-exposed <command> [options]        (or: npx a2a-exposed <command>)
+Usage: npx -y a2a-exposed@latest <command> [options]
+       (optional speed-up: npm i -g a2a-exposed, then a2a-exposed <command>)
 
-Setup (needs Node 22.18+, e.g. \`mise exec node@22 -- npx a2a-exposed ...\`, and a Cloudflare login:
+Setup (needs Node 22.18+, e.g. \`mise exec node@22 -- npx -y a2a-exposed@latest ...\`, and a Cloudflare login:
 npx cf auth login --no-browser; on a VPS where it fails with HTTP 403 before showing a code, export
 CLOUDFLARE_API_TOKEN instead: setup skill, Troubleshooting)
   init [--hostname <host> | --workers-dev [--workers-dev-subdomain NAME]]
        [--agent-name N] [--agent-description D] [--agent-skills JSON]
        [--provider-organization O --provider-url U] [--preset P] [--worker-name W] [--d1-name D]
        [--account-id ID] [--cf-profile NAME] [--cli-command CMD] [--debounce S] [--max-per-hour N]
-       [--pairing-approval human|agent|off] [--pbkdf2-iterations N] [--workers-logs on|off] [--cron]
+       [--pairing-approval human|agent|off] [--pbkdf2-iterations N] [--workers-logs on|off] [--mcp on|off] [--cron]
        [--upstream URL [--upstream-card-url URL] [--upstream-token-stdin | --no-upstream-token]] [--worker-dir DIR]
                                 deploy the Worker + D1 to your account; wake secrets are read from
                                 env WAKE_WEBHOOK_URL / WAKE_WEBHOOK_KEY / WAKE_HMAC_SECRET (never argv)
@@ -39,6 +40,8 @@ CLOUDFLARE_API_TOKEN instead: setup skill, Troubleshooting)
                                 --pbkdf2-iterations  approval-password hashing cost, 50000-100000 (default 100000,
                                                the Workers maximum; lower only if /device hits error 1102)
                                 --workers-logs on|off  persisted Cloudflare Workers Logs (query strings redacted)
+                                --mcp on|off   remote MCP server at <url>/mcp for Claude and other MCP clients
+                                               (default on; each client needs your approval password once)
                                 --upstream URL  proxy / expose mode: a public façade for an agent that already
                                                speaks A2A (JSON-RPC) on a private network. URL is its endpoint on
                                                a Cloudflare Tunnel hostname behind Access (never a Tailnet/LAN
@@ -55,7 +58,7 @@ CLOUDFLARE_API_TOKEN instead: setup skill, Troubleshooting)
                                                on a terminal, else exit 1 with what to do
                                 --upstream-token-stdin  read UPSTREAM_TOKEN from stdin (hidden prompt on a terminal)
                                 --no-upstream-token  the upstream needs no bearer token: skip that check (saved)
-                                --cli-command  command shown in wake hints (default "npx a2a-exposed";
+                                --cli-command  command shown in wake hints (default "npx -y a2a-exposed@latest";
                                                e.g. "node /path/to/repo/cli/bin/a2a-exposed.mjs")
                                 --worker-dir   where the Worker project (template copy) lives (default
                                                <config dir>/worker; --dir is the old name). Not the config dir:
@@ -108,6 +111,9 @@ Inbox (owner side)
         [--artifact] [--artifact-name N] [--force]
   history <contextId> [-n 50] [--json]     conversation log
   contexts                                 recent conversations
+  export [--sql]                       JSON dump of this inbox on stdout (peer-token hashes and
+                                       encrypted peer tokens are in the dump; the owner token stays
+                                       a Worker secret). --sql prints the same tables as SQL
 
 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]
@@ -125,6 +131,12 @@ Pairing (OAuth 2.0 device flow, RFC 8628: agents connect without pasting tokens
                           approval password on a web page. Send it to them privately; never open or fill it
                           yourself. A new link invalidates the previous one
   pair set-password       the same in a terminal, no echo (the human runs it; never via argv/stdin)
+  pair set-oidc --issuer URL --client-id ID --subjects SUB[,SUB...] [--methods password,oidc] [--secret-stdin]
+                          optional OpenID Connect approval on /device and the MCP consent page. The client
+                          secret is APPROVAL_OIDC_CLIENT_SECRET in the environment, or one line on stdin with
+                          --secret-stdin. It is not a flag and it is not saved in config.env. The next
+                          \`npx -y a2a-exposed@latest deploy\` uploads that environment variable as a Worker
+                          secret. Leave the issuer unset and approval stays the password page
   pair list [--json]      pending pairing requests (code, claimed name/card, address), the approval mode and
                           when the approval password was set
   pair approve <code>     approve (only with --pairing-approval agent, after your human said yes)
@@ -133,12 +145,16 @@ Pairing (OAuth 2.0 device flow, RFC 8628: agents connect without pasting tokens
 Inbound peer tokens (one per peer label; paired agents get one too)
   token issue <label>     print a new token once (fails if the label is active); manual fallback to \`connect\`
   token rotate <label>    replace the label's token
-  token list | token revoke <label>        list shows how each token was created (pairing: code + date);
+  token list | token revoke <label>        list shows how each token was created (pairing: code + date)
+                                           and MCP connectors (label mcp-*); revoke works for both;
                                            revoke of an unknown label exits 1
 
 Outbound (agents you call)
   peers add <alias> <url> [--token-env VAR | --token-stdin]
   peers list | peers rm <alias>
+  peers sync [alias...] | peers unsync <alias>
+                          upload peers (URL + token, encrypted on the Worker) so the MCP connector can send to
+                          them; default: all peers. Re-run after connect, token changes or an owner-token rotation
                           a token variable set in the environment overrides config.env; when a peer token
                           differs between the two, connect/send/poll/peers/status warn (values never shown)
   send --to <alias|url> [--text T | stdin] [--context C] [--task T] [--push] [--proto 0.3|1.0]
@@ -165,9 +181,10 @@ const SPEC = {
 	send: { to: S, text: S, context: S, task: S, push: B, proto: S },
 	poll: { to: S, proto: S },
 	status: { json: B },
+	export: { sql: B },
 	upstream: { json: B },
 	connect: { alias: S, name: S, json: B, "no-wait": B, replace: B, force: B, "card-url": S },
-	pair: { json: B, web: B, ttl: S },
+	pair: { json: B, web: B, ttl: S, issuer: S, "client-id": S, subjects: S, methods: S, "secret-stdin": B },
 };
 const STATES = ["completed", "input-required", "failed", "rejected", "working"];
 
@@ -181,6 +198,8 @@ export async function main(argv) {
 	if (!name || name === "help" || name === "--help" || name === "-h") return console.log(HELP);
 	if (name === "--version" || name === "-v") return console.log(VERSION);
 	if (rest.includes("--help") || rest.includes("-h")) return console.log(HELP);
+	if (name === "pair" && rest[0] === "set-oidc" && rest.some((a) => /^--(secret|client-secret)(=|$)/.test(a)))
+		throw new CliError("the OpenID Connect client secret is not a flag: export APPROVAL_OIDC_CLIENT_SECRET or pass --secret-stdin (it is not saved in config.env)");
 	if (name === "pair" && rest[0] === "set-password") {
 		// only --web [--ttl M] [--json]: the password itself never comes from argv, stdin or the environment
 		const extra = rest.slice(1);
@@ -197,7 +216,7 @@ export async function main(argv) {
 			await dep.init(o);
 			if (!o.tunnel) return;
 			try { return await tun.create(o); } catch (e) {
-				if (e instanceof CliError) e.message += "\n(the inbox is deployed and works; fix the above, then run `a2a-exposed tunnel create`, or check `a2a-exposed status`)";
+				if (e instanceof CliError) e.message += `\n(the inbox is deployed and works; fix the above, then run \`${CLI} tunnel create\`, or check \`${CLI} status\`)`;
 				throw e;
 			}
 		case "tunnel": return tun.tunnel(need(p[0], "tunnel create|status|rm"), o);
@@ -211,7 +230,7 @@ export async function main(argv) {
 		case "wake": return dep.wake(p[0], o);
 		case "url": {
 			const u = cmd.baseUrl();
-			if (!u) throw new CliError(`no base URL configured in ${C.CONFIG_FILE}: run \`a2a-exposed init\` (or pass --config-dir / A2A_CONFIG_DIR for another deployment)`);
+			if (!u) throw new CliError(`no base URL configured in ${C.CONFIG_FILE}: run \`${CLI} init\` (or pass --config-dir / A2A_CONFIG_DIR for another deployment)`);
 			return console.log(u);
 		}
 		case "config": {
@@ -228,15 +247,17 @@ export async function main(argv) {
 			return cmd.reply(need(p[0], "reply <taskId> --text ..."), o);
 		case "history": return cmd.history(need(p[0], "history <contextId>"), o);
 		case "contexts": return cmd.contexts();
+		case "export": return cmd.exportInbox(o);
 		case "token": return cmd.token(need(p[0], "token issue|list|revoke|rotate [label]"), p[1], o);
 		case "peers": return cmd.peers(p[0] || "list", p.slice(1), o);
 		case "connect": return pair.connect(need(p[0], "connect <base-or-card-url> [--alias A] [--no-wait] [--json]"), o);
 		case "pair": {
-			const sub = need(p[0], "pair set-password|list|approve <code>|deny <code>");
+			const sub = need(p[0], "pair set-password|set-oidc|list|approve <code>|deny <code>");
 			if (sub === "set-password") return pair.setPassword(o);
+			if (sub === "set-oidc") return pair.setOidc(o, p.slice(1));
 			if (sub === "list") return pair.list(o);
 			if (sub === "approve" || sub === "deny") return pair.decide(sub, need(p[1], `pair ${sub} <code>`));
-			throw new CliError(`unknown pair action ${sub} (set-password|list|approve|deny)`);
+			throw new CliError(`unknown pair action ${sub} (set-password|set-oidc|list|approve|deny)`);
 		}
 		case "send": return cmd.send(o);
 		case "poll": return cmd.poll(need(p[0], "poll --to <peer> <taskId>"), o);

package/lib/pair.mjs

@@ -1,14 +1,13 @@
 // Device-flow pairing (OAuth 2.0 Device Authorization Grant, RFC 8628).
-//   Owner side (this inbox is the authorization server): pair set-password | list | approve | deny
+//   Owner side (this inbox is the authorization server): pair set-password | set-oidc | list | approve | deny
 //   Client side (connect to another inbox): connect <base-or-card-url>
 import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import * as C from "./config.mjs";
-import { describeHttp, die, fetchCard, httpJson, isPrivateHost, pickEndpoint } from "./a2a.mjs";
+import { CLI, describeHttp, die, fetchCard, httpJson, isPrivateHost, pickEndpoint } from "./a2a.mjs";
 import { baseUrl, peerToken, warnPeerTokenEnv } from "./commands.mjs";
 
-const CLI = "a2a-exposed";
 export const DEVICE_GRANT = "urn:ietf:params:oauth:grant-type:device_code";
 export const PBKDF2_ITERATIONS = 100000; // default (the Workers runtime's maximum); the Worker advertises its own setting
 export const MIN_PASSWORD_LENGTH = 12;
@@ -102,6 +101,50 @@ No terminal? \`${CLI} pair set-password --web\` prints a one-time link where you
 	console.error(`Approve pairing requests at ${baseUrl()}/device: a webhook wake carries each request's direct link; polling agents see requests in \`${CLI} inbox\` and \`${CLI} pair list\`.${r.data.mode === "human" ? "" : ` Note: approval mode is ${r.data.mode}.`}`);
 }
 
+/** `pair set-oidc`: non-secret settings in config.env. The client secret stays in the environment (or was read from stdin and discarded). */
+export async function setOidc(o, extra = []) {
+	if (extra.length) die("pair set-oidc takes no extra arguments. The client secret is not an argument: export APPROVAL_OIDC_CLIENT_SECRET or pass --secret-stdin");
+	if (!o.issuer || !o["client-id"] || !o.subjects) die("usage: pair set-oidc --issuer https://idp.example --client-id ID --subjects sub@example.com[,other] [--methods password,oidc] [--secret-stdin]");
+	let issuer;
+	try { issuer = new URL(String(o.issuer).trim()); } catch { die("--issuer must be an https URL"); }
+	if (issuer.protocol !== "https:" || issuer.username || issuer.password) die("--issuer must be an https URL with no user name or password");
+	const clientId = String(o["client-id"]).trim();
+	if (!clientId || clientId.length > 200 || /\s/.test(clientId)) die("--client-id must be a single token, at most 200 characters");
+	const subjects = String(o.subjects).split(",").map((s) => s.trim()).filter(Boolean);
+	if (!subjects.length || subjects.some((s) => s.length > 320 || /[\r\n]/.test(s))) die("--subjects is a comma-separated list of allowed sub or email values");
+	let methods;
+	if (o.methods !== undefined) {
+		const parts = String(o.methods).split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
+		if (!parts.length || parts.some((p) => p !== "password" && p !== "oidc")) die("--methods is a comma-separated list of password and oidc");
+		methods = [...new Set(parts)].join(",");
+	}
+	let sawStdin = false;
+	if (o["secret-stdin"]) {
+		if (process.stdin.isTTY) die("--secret-stdin reads the client secret from a pipe. Or export APPROVAL_OIDC_CLIENT_SECRET. It is not saved in config.env");
+		const chunks = [];
+		for await (const c of process.stdin) chunks.push(c);
+		const secret = Buffer.concat(chunks).toString("utf8").replace(/\r?\n$/, "");
+		if (!secret || /[\r\n]/.test(secret)) die("the client secret must be a single non-empty line on stdin");
+		sawStdin = true;
+		const fromEnv = process.env.APPROVAL_OIDC_CLIENT_SECRET || "";
+		if (fromEnv && fromEnv !== secret) console.error("The secret on stdin differs from APPROVAL_OIDC_CLIENT_SECRET. Deploy uploads the environment variable. Neither value was printed or saved.");
+	} else if (!(process.env.APPROVAL_OIDC_CLIENT_SECRET || "").trim()) {
+		die("export APPROVAL_OIDC_CLIENT_SECRET or pass --secret-stdin. The client secret is not a flag and is not saved in config.env");
+	}
+	C.saveConfig({
+		APPROVAL_OIDC_ISSUER: String(o.issuer).trim(),
+		APPROVAL_OIDC_CLIENT_ID: clientId,
+		APPROVAL_OIDC_ALLOWED_SUBJECTS: subjects.join(","),
+		...(methods !== undefined ? { APPROVAL_METHODS: methods } : {}),
+	});
+	console.error(`OpenID Connect approval saved in ${C.CONFIG_FILE} (issuer, client id, allowed subjects${methods !== undefined ? ", methods" : ""}).`);
+	console.error("The client secret was not written there and was not printed.");
+	if (sawStdin && !(process.env.APPROVAL_OIDC_CLIENT_SECRET || "").trim())
+		console.error(`Export APPROVAL_OIDC_CLIENT_SECRET in the environment you use for deploy. This command did not store it.`);
+	console.error(`The next \`npx -y a2a-exposed@latest deploy\` uploads APPROVAL_OIDC_CLIENT_SECRET from the environment as a Worker secret.`);
+	console.error("Password approval stays available unless --methods oidc (and only once the issuer, client id, secret and allowlist are all set).");
+}
+
 // ---------------------------------------------------------------- owner: list / approve / deny
 export async function list(o) {
 	const r = await ownerCall("GET", "/owner/pairing");
@@ -115,6 +158,7 @@ export async function list(o) {
 	if (d.mode !== "off") {
 		console.log(`approval password: ${d.passwordSet ? `set${d.passwordSetAt ? ` ${d.passwordSetAt}` : ""}${d.passwordSetVia ? ` (via ${d.passwordSetVia})` : ""}`
 			: `NOT SET: run \`${CLI} pair set-password --web\` and send your human the one-time link (or they run \`${CLI} pair set-password\` in a terminal)`}`);
+		if (d.oidcIssuer) console.log(`OpenID Connect: ${(d.approvalMethods || []).join(" and ")} (${d.oidcIssuer})`);
 		if (d.setupLinkExpiresAt) console.log(`setup link: one is open until ${d.setupLinkExpiresAt} (a new \`pair set-password --web\` replaces it)`);
 	}
 	if (!d.pending.length) return console.log("(no pending pairing requests)");