From 6e41e6a51159b1e14db0e42097279b1ba9d7139c Mon Sep 17 00:00:00 2001 From: khaliqgant Date: Thu, 19 Nov 2026 12:31:03 -0800 Subject: [PATCH 1/2] fix(mcp): bound relay discovery reads --- CHANGELOG.md | 1 + src/mcp/capabilities.ts | 10 +++++--- src/mcp/relay-participants.ts | 23 ++++++++++++++--- src/mcp/team-activity.ts | 10 ++++---- test/mcp.test.ts | 48 ++++++++++++++++++++++++++++++++--- 5 files changed, 78 insertions(+), 14 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 3a79f88c..edd8e962 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -12,6 +12,7 @@ assigned at release. - Added: every MCP `list_session_summaries` row now includes `transcript_status: "not_verified"`, because directory publication does not prove that the transcript index is readable yet. - Changed: on a managed Desktop connection whose synced identity cannot be verified, MCP `describe_capabilities` keeps `relay_messaging` available for `list_relay_agents` and `get_relay_agent_card` while listing every actor-dependent tool in `restricted_tools`, with the safe refusal reason or retry guidance. - Fixed: `check_relay_inbox` bounds sender-address enrichment to one second and still returns pending messages with a null address when the lookup fails or stalls. +- Fixed: MCP `list_relay_agents` now bounds its upstream roster read at 10 seconds, `describe_capabilities` bounds managed native-identity verification at 2 seconds, and `relay_status` bounds optional exact-name address enrichment at 1 second while returning the status with a null address on lookup failure or timeout. - Added: Cursor cloud agents can join Agent Relay as their own runs (migration 0081; docs/cursor-cloud-agents.md). A Cursor cloud agent connects with the person's OAuth grant from cursor.com/agents. It proves which run it is with a Cursor-signed OIDC token, minted in its VM for this server's audience and the grant's nonce, and verified against api.cursor.com's keys, once. It then joins with `join_relay` `cursor_identity_token` as `cursor-cloud-` and acts with `as`. The Cursor account must first be linked to the person: they confirm a one-time link in the browser, or the operator trusts their Cursor team (`SELFHOST_CURSOR_CLOUD_TRUSTED_TEAMS`) and the token carries their own email. `SELFHOST_CURSOR_CLOUD_RUN_IDENTITY=required` refuses the connection's shared agent. Revoking the connection releases its runs. - Changed: OAuth connections with a `cursor.com/agents` callback are now the `cursor-cloud` connector kind (cards, relaygate `clients`), not `grok-bot`; x.ai callbacks stay `grok-bot`. Grok Bot routines work for both kinds. **On gate-only installs**, a Cursor-hosted Grok Bot that relaygate admitted as `grok-bot` re-enrols as `cursor-cloud` on next use. Add `"cursor-cloud"` to the relaygate rule that allows `"grok-bot"`. - Changed: the MCP endpoint's `[selfhost-mcp] native chat context refused` log diff --git a/src/mcp/capabilities.ts b/src/mcp/capabilities.ts index 2f5f99a8..a512adfc 100644 --- a/src/mcp/capabilities.ts +++ b/src/mcp/capabilities.ts @@ -3,9 +3,11 @@ import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; import { CAPABILITY_DISCOVERY_TOOL, describeCapabilities } from "./catalog.js"; import type { McpContext } from "./context.js"; import { RelayToolError, relayService } from "./relay-participants.js"; +import { withinRelayRead } from "./team-activity.js"; const NATIVE_CHECK_RETRY_REASON = "Agent Relay could not check this chat's synced Desktop identity right now. Retry describe_capabilities."; const NATIVE_CHECK_RETRY_GUIDANCE = "Retry shortly. If the check keeps failing, ask the operator to verify Relay and database health."; +const NATIVE_CAPABILITY_CHECK_TIMEOUT_MS = 2_000; /** * describe_capabilities, ported from Cloud's @@ -14,7 +16,7 @@ const NATIVE_CHECK_RETRY_GUIDANCE = "Retry shortly. If the check keeps failing, * one it cannot use. Read-only; the role was read at admission. */ export function registerCapabilityDiscovery(server: McpServer, context: McpContext, - options: { nativeStatus?: () => Promise } = {}): void { + options: { nativeStatus?: () => Promise; nativeTimeoutMs?: number } = {}): void { server.registerTool(CAPABILITY_DISCOVERY_TOOL, { title: "Describe this connection's capabilities", description: "Use when an expected Agent Relay capability is missing or an operation is refused. Returns this MCP connection's endpoint, authentication mode, granted scopes, current workspace role and tool groups. A group can remain available for directory reads while actor-dependent calls appear in restricted_tools as { name, reason }; unavailable or fully restricted groups include the exact reason and enablement requirements. Read-only.", @@ -29,8 +31,10 @@ export function registerCapabilityDiscovery(server: McpServer, context: McpConte // identity would add a database and Relay round trip without changing the report. if (managed && context.authMode !== "staff_read_grant") { try { - if (options.nativeStatus) await options.nativeStatus(); - else await relayService(context).status(); + await withinRelayRead( + () => options.nativeStatus ? options.nativeStatus() : relayService(context).status(), + options.nativeTimeoutMs ?? NATIVE_CAPABILITY_CHECK_TIMEOUT_MS, + ); nativeAuthorityAvailable = true; } catch (error) { nativeAuthorityAvailable = false; diff --git a/src/mcp/relay-participants.ts b/src/mcp/relay-participants.ts index ceb9e7f9..a65eb6fb 100644 --- a/src/mcp/relay-participants.ts +++ b/src/mcp/relay-participants.ts @@ -10,7 +10,7 @@ import { type DesktopIdentityRow, type LinkedDesktopIdentity, } from "../messaging/desktop-identities.js"; import type { McpContext, McpMember } from "./context.js"; -import { isListedRelayAgent, rosterAgent } from "./team-activity.js"; +import { isListedRelayAgent, rosterAgent, ROSTER_TIMEOUT_MS, withinRelayRead } from "./team-activity.js"; import { buildAgentCard, cardMetadata, cardSummary, recipientCard, type SetCardInput } from "./relay-agent-cards.js"; import { loadRelayAgentOwners, relayAgentOwnerTarget } from "./relay-agent-owners.js"; import { McpOAuthAccessRefused, McpOAuthActorRefused } from "./oauth/admission.js"; @@ -80,6 +80,11 @@ const inboxSenderEnrichmentFailed = (error: unknown) => { operation: "check_relay_inbox", error: error instanceof Error ? error.name : "unknown", }); }; +const relayStatusAddressEnrichmentFailed = (error: unknown) => { + console.warn("[selfhost-mcp] relay status address enrichment failed", { + operation: "relay_status", error: error instanceof Error ? error.name : "unknown", + }); +}; const sessionEnrichmentFailed = (error: unknown) => { console.warn("[selfhost-mcp] session enrichment failed", { operation: "list_relay_agents", error: error instanceof Error ? error.name : "unknown", @@ -115,6 +120,7 @@ const DESKTOP_LINK_NEEDS_SESSION = "Initialize MCP to receive Mcp-Session-Id bef const DESKTOP_LINK_OAUTH = "This connection acts only as the agent approved for it and cannot link a desktop identity. Use a native MCP session (one that keeps Mcp-Session-Id) to call join_relay with desktop_address."; const DESKTOP_INBOX_GUIDANCE = "Replies are injected into your session by Agent Relay Desktop; check_relay_inbox is not used for this linked identity."; const INBOX_SENDER_LOOKUP_TIMEOUT_MS = 1_000; +const RELAY_STATUS_LOOKUP_TIMEOUT_MS = 1_000; const CHANNEL_REPLY_GUIDANCE = "Reply to a post in this channel with post_relay_channel channel= thread_id=. Use send_relay_message only when the reply is private."; const RESERVED_CHANNEL_PREFIX = "agent-events-"; const CHANNEL_NAME = /^[a-z0-9][a-z0-9_-]{0,79}$/; @@ -739,7 +745,10 @@ function createRelayService(context: McpContext) { } async function listedAgents(status: "active" | "all", includeStale = false, dir: Directory = directory()) { - return (await dir.via.listAgents(dir.credential, status, { includeStale })).filter(isListedRelayAgent); + return (await withinRelayRead( + signal => dir.via.listAgents(dir.credential, status, { includeStale, signal }), + ROSTER_TIMEOUT_MS, + )).filter(isListedRelayAgent); } const syncedSessionKinds = new Set(["codex", "grok", "pi", "opencode", "claude", "copilot", "cursor"]); @@ -1584,7 +1593,15 @@ function createRelayService(context: McpContext) { ...(cursor ? { cursor_identity: cursor } : {}), guidance: "Send a message with send_relay_message to auto-join this MCP session, or call join_relay first." }; await touchPresence(hosted); - const [address, inbox] = await Promise.all([addressFor(hosted.name, false, directory(hosted)), clientFor(hosted).readHostedInbox(hosted.token)]); + const dir = directory(hosted); + const [agents, inbox] = await Promise.all([ + withinRelayRead( + signal => dir.via.findAgentsByNames(dir.credential, [hosted.name], { signal }), + RELAY_STATUS_LOOKUP_TIMEOUT_MS, + ).catch(error => { relayStatusAddressEnrichmentFailed(error); return []; }), + clientFor(hosted).readHostedInbox(hosted.token), + ]); + const address = agents.find(agent => agent.name === hosted.name)?.address ?? null; return { joined: true, linked: "hosted" as const, name: hosted.name, address, unread_count: inbox.length, unread_count_is_lower_bound: inbox.length === 100, ...(cursor && !await ownRun(as) ? { cursor_identity: cursor } : {}) }; diff --git a/src/mcp/team-activity.ts b/src/mcp/team-activity.ts index 34895726..3722e36c 100644 --- a/src/mcp/team-activity.ts +++ b/src/mcp/team-activity.ts @@ -19,7 +19,7 @@ import { assertEventScope, boundedContent, buildDirectEventsPath, resolveWorkspa const MAX_CONTENT_LENGTH = 4_000; const ROSTER_UNAVAILABLE = "Workspace relay roster is temporarily unavailable. Please try again."; /** Bound on the Relaycast roster read; without the roster the tool fails. */ -const ROSTER_TIMEOUT_MS = 10_000; +export const ROSTER_TIMEOUT_MS = 10_000; /** * Bound on the Relaycast presence read. Presence is optional, so a stalled * presence service gives way early and the roster is returned without it. @@ -35,7 +35,7 @@ export type TeamActivityLimits = { rosterTimeoutMs?: number; presenceTimeoutMs?: * Run `read` with a signal aborted after `ms`, and stop waiting then even if * the read ignores the signal. A late result or rejection is dropped. */ -function within(read: (signal: AbortSignal) => Promise, ms: number): Promise { +export function withinRelayRead(read: (signal: AbortSignal) => Promise, ms: number): Promise { const controller = new AbortController(); let timer: ReturnType | undefined; const timeout = new Promise((_, reject) => { @@ -205,9 +205,9 @@ async function readTeam( context: McpContext, status: "live" | "all", rosterTimeoutMs: number, presenceTimeoutMs: number, ): Promise<{ agents: TeamAgent[]; presenceAvailable: boolean }> { const [rosterResult, presenceResult, people] = await Promise.all([ - Promise.allSettled([within(signal => context.relaycast.listAgents(status === "live" ? "active" : "all", { signal }), rosterTimeoutMs)]) + Promise.allSettled([withinRelayRead(signal => context.relaycast.listAgents(status === "live" ? "active" : "all", { signal }), rosterTimeoutMs)]) .then(([result]) => result!), - Promise.allSettled([within(signal => context.relaycast.listPresence({ signal }), presenceTimeoutMs)]).then(([result]) => result!), + Promise.allSettled([withinRelayRead(signal => context.relaycast.listPresence({ signal }), presenceTimeoutMs)]).then(([result]) => result!), context.members(), ]); if (rosterResult.status === "rejected") { @@ -335,7 +335,7 @@ export async function readTeamActivity( await Promise.all(candidates.slice(i, i + 5).map(async ({ key, sessionId, source }) => { try { // A read still pending at the deadline is unavailable; its late answer is dropped. - const parsed = SessionEventsPageSchema.safeParse(await within(() => context.readHistory( + const parsed = SessionEventsPageSchema.safeParse(await withinRelayRead(() => context.readHistory( buildDirectEventsPath(sessionId, { source, limit: 1, order: "desc", maxContent: input.max_content })), remaining)); if (!parsed.success || parsed.data.sessionId !== sessionId) { throw new SharedSessionsToolError("Unsupported session response."); diff --git a/test/mcp.test.ts b/test/mcp.test.ts index dc54ce9a..b7dffec5 100644 --- a/test/mcp.test.ts +++ b/test/mcp.test.ts @@ -152,6 +152,9 @@ function fakeRelaycast(state: { agents: unknown[]; presence: unknown[] | "fail"; calls: RelaycastCall[]; world: RelaycastWorld; /** The bounded `names` lookup: "fail" answers 503; "hang" waits for abort; "roster" ignores `names`. */ namesLookup?: "fail" | "hang" | "roster"; + /** A deliberately non-cooperative full-roster read, used to prove the outer MCP deadline. */ + rosterLookup?: "hang"; + rosterSignal?: AbortSignal; }): typeof fetch { return (async (input: string | URL | Request, init?: RequestInit) => { const url = new URL(String(input instanceof Request ? input.url : input)); @@ -163,6 +166,10 @@ function fakeRelaycast(state: { }); if (url.pathname === "/v1/agents" && (init?.method ?? "GET") === "GET") { const names = url.searchParams.getAll("names"); + if (state.rosterLookup === "hang" && names.length === 0) { + state.rosterSignal = init?.signal ?? undefined; + return await new Promise(() => {}); + } if (state.namesLookup === "fail" && names.length) return json(503, { ok: false, error: { code: "unavailable" } }); if (state.namesLookup === "hang" && names.length) { return await new Promise((_resolve, reject) => { @@ -193,7 +200,8 @@ async function setup(t: TestContext, telemetry?: TelemetryModule) { const history = await startHistory(t); const agents: unknown[] = []; const relay = { agents, presence: [] as unknown[] | "fail", calls: [] as RelaycastCall[], world: createRelaycastWorld(agents), - namesLookup: undefined as "fail" | "hang" | "roster" | undefined }; + namesLookup: undefined as "fail" | "hang" | "roster" | undefined, + rosterLookup: undefined as "hang" | undefined, rosterSignal: undefined as AbortSignal | undefined }; const database = new PGliteDatabase(); await migrate(database); const config: SelfhostConfig = { @@ -552,11 +560,11 @@ test("the capability handler preserves safe refusals, distinguishes outages, and endpointUrl: "https://relay.example.test/mcp", authMode: "cli_login", role: "owner", principal: { scopes: ["cli:auth"] }, workspace: { id: "workspace" }, providers: async () => [], }; - async function call(required: boolean, nativeStatus: () => Promise, authMode = "cli_login") { + async function call(required: boolean, nativeStatus: () => Promise, authMode = "cli_login", nativeTimeoutMs?: number) { let handler: (() => Promise<{ structuredContent: Record }>) | undefined; registerCapabilityDiscovery({ registerTool: (_name: string, _definition: unknown, run: typeof handler) => { handler = run; } } as never, { ...baseContext, authMode, desktopCall: { required, nativeSession: required ? { kind: "codex", id: "native" } : undefined } } as unknown as McpContext, - { nativeStatus }); + { nativeStatus, nativeTimeoutMs }); return (await handler!()).structuredContent as { groups: Array<{ id: string; status: string; reason?: string; how_to_enable?: string; restricted_tools?: Array<{ name: string; reason: string }> }> }; } @@ -578,6 +586,12 @@ test("the capability handler preserves safe refusals, distinguishes outages, and assert.doesNotMatch(unavailableReason, /private outage details|reconnect/i); assert.deepEqual(warnings, [["[selfhost-mcp] native identity capability check failed", { error: "Error" }]]); + const timedOut = await call(true, () => new Promise(() => {}), "cli_login", 5); + const timeoutReason = timedOut.groups.find(group => group.id === "relay_messaging")?.restricted_tools + ?.find(tool => tool.name === "send_relay_message")?.reason ?? ""; + assert.match(timeoutReason, /could not check.*right now/i); + assert.deepEqual(warnings.at(-1), ["[selfhost-mcp] native identity capability check failed", { error: "Error" }]); + const available = await call(true, async () => { checks += 1; }); assert.equal(checks, 3); assert.equal(available.groups.find(group => group.id === "relay_messaging")?.status, "available"); @@ -764,6 +778,23 @@ test("join_relay by name registers a hosted participant with Cloud's metadata", assert.deepEqual({ joined: status.joined, name: status.name, unread: status.unread_count }, { joined: true, name: "owner-helper", unread: 0 }); }); +test("relay_status returns with a null address when its bounded exact-name lookup stalls", async (t) => { + const env = await setup(t); + const client = await relayClient(t, env); + structured(await client.callTool({ name: "join_relay", arguments: { name: "owner-status" } })); + env.relay.namesLookup = "hang"; + const warnings: unknown[][] = []; + t.mock.method(console, "warn", (...args: unknown[]) => warnings.push(args)); + const started = Date.now(); + const status = structured(await client.callTool({ name: "relay_status", arguments: {} })); + assert(Date.now() - started < 2_500, "status address enrichment stays within its one-second budget"); + assert.equal(status.joined, true); + assert.equal(status.name, "owner-status"); + assert.equal(status.address, null); + assert.deepEqual(warnings, [["[selfhost-mcp] relay status address enrichment failed", + { operation: "relay_status", error: "Error" }]]); +}); + test("join_relay is idempotent, defaults its name, and refuses a foreign owner's agent", async (t) => { const env = await setup(t); const client = await relayClient(t, env); @@ -886,6 +917,17 @@ test("every listed Desktop and spawned agent has an inferred card and trusted ow assert.equal(env.relay.world.bodies.some(call => call.method === "PATCH"), false); }); +test("list_relay_agents stops waiting after ten seconds when the roster ignores cancellation", async (t) => { + const env = await setup(t); + const client = await relayClient(t, env); + env.relay.rosterLookup = "hang"; + const started = Date.now(); + assert.match(toolError(await client.callTool({ name: "list_relay_agents", arguments: { status: "all" } })), + /relay operation failed/i); + assert(Date.now() - started < 12_500, "the MCP roster read stays within its ten-second budget"); + assert.equal(env.relay.rosterSignal?.aborted, true); +}); + test("list_relay_agents links synced Desktop sessions and keeps validated declarations authoritative", async (t) => { const env = await setup(t); const synced = env.relay.world.addAgent("synced-session", { source: "relay-desktop", owner_hash: sha256(env.ownerId) }); From 167355acb191f995de0118dfc1f56d01909a13a2 Mon Sep 17 00:00:00 2001 From: khaliqgant Date: Thu, 19 Nov 2026 12:48:45 -0800 Subject: [PATCH 2/2] fix(mcp): preserve renamed status filtering --- src/mcp/relay-participants.ts | 2 +- test/mcp.test.ts | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/src/mcp/relay-participants.ts b/src/mcp/relay-participants.ts index a65eb6fb..81528244 100644 --- a/src/mcp/relay-participants.ts +++ b/src/mcp/relay-participants.ts @@ -1601,7 +1601,7 @@ function createRelayService(context: McpContext) { ).catch(error => { relayStatusAddressEnrichmentFailed(error); return []; }), clientFor(hosted).readHostedInbox(hosted.token), ]); - const address = agents.find(agent => agent.name === hosted.name)?.address ?? null; + const address = agents.find(agent => agent.name === hosted.name && isListedRelayAgent(agent))?.address ?? null; return { joined: true, linked: "hosted" as const, name: hosted.name, address, unread_count: inbox.length, unread_count_is_lower_bound: inbox.length === 100, ...(cursor && !await ownRun(as) ? { cursor_identity: cursor } : {}) }; diff --git a/test/mcp.test.ts b/test/mcp.test.ts index b7dffec5..eb1f005b 100644 --- a/test/mcp.test.ts +++ b/test/mcp.test.ts @@ -776,6 +776,8 @@ test("join_relay by name registers a hosted participant with Cloud's metadata", const status = structured(await client.callTool({ name: "relay_status", arguments: {} })); assert.deepEqual({ joined: status.joined, name: status.name, unread: status.unread_count }, { joined: true, name: "owner-helper", unread: 0 }); + (remote.metadata as Record).renamed_to = "owner-successor"; + assert.equal(structured(await client.callTool({ name: "relay_status", arguments: {} })).address, null); }); test("relay_status returns with a null address when its bounded exact-name lookup stalls", async (t) => {