From dc018f9bc0a4ae526351722fb1782577d0fd0bb3 Mon Sep 17 00:00:00 2001 From: Devin Foley Date: Fri, 13 Nov 2026 18:45:20 -0800 Subject: [PATCH] Keep agent-owned connections healthy during catalog refresh (#21539) Use dedicated agent grants for catalog refresh, GitHub health checks, and reconnect status. Preserve shared connection health when a different agent lacks authorization. Add PostgreSQL and HTTP regressions for credential selection, stale health recovery, caller isolation, and actual provider rejection. Correct the MCP demo approval fixture to submit a valid saved-card option through normal answer validation. Validation: 629 focused tests, server typecheck, all CI checks, and Greptile 5/5 with no unresolved review comments. Co-Authored-By: Paperclip --- doc/connections/CONNECTOR-PLAYBOOK.md | 10 + ...ent-connection-catalog.integration.test.ts | 214 ++++++++++++++++++ .../__tests__/github-health-recovery.test.ts | 1 + .../__tests__/mcp-tasks-demo-server.test.ts | 13 +- server/src/services/tool-access.ts | 8 +- .../services/tool-access/catalog/failures.ts | 10 +- .../services/tool-access/catalog/health.ts | 10 +- .../tool-access/catalog/publication.ts | 3 +- .../services/tool-access/credential-access.ts | 27 +++ 9 files changed, 284 insertions(+), 12 deletions(-) create mode 100644 server/src/__tests__/agent-connection-catalog.integration.test.ts diff --git a/doc/connections/CONNECTOR-PLAYBOOK.md b/doc/connections/CONNECTOR-PLAYBOOK.md index a5df04b1c6f..26eaaadc723 100644 --- a/doc/connections/CONNECTOR-PLAYBOOK.md +++ b/doc/connections/CONNECTOR-PLAYBOOK.md @@ -181,6 +181,16 @@ refs and the same ownership checks. A personal resolver must not fall back to a company credential. Ownership mismatch is `grant_credential_invalid` and tells the owner to reconnect. +Dedicated agent connections keep credentials on their agent grant. Background +catalog and health work may use a single active grant for that connection and +company. An agent caller must use its own grant. Missing, revoked, or ambiguous +agent authorizations fail before provider requests; they never fall back to a +personal, organization, or connection-owned credential. Renaming or pausing the +connection must preserve the grant and its secret bindings. A later successful +catalog refresh clears an earlier connection-health error without new consent. +An agent caller denied for lacking its own grant must not change shared health +or the catalog, including when that agent has permission to manage the connection. + Existing personal connections with company-scoped invocation credentials require their owner to reconnect and enter a fresh key or secret URL. Reconnect creates a user-owned credential and updates the grant and declarations while preserving diff --git a/server/src/__tests__/agent-connection-catalog.integration.test.ts b/server/src/__tests__/agent-connection-catalog.integration.test.ts new file mode 100644 index 00000000000..e92d11bafaa --- /dev/null +++ b/server/src/__tests__/agent-connection-catalog.integration.test.ts @@ -0,0 +1,214 @@ +import { randomUUID } from "node:crypto"; +import { createServer, type Server } from "node:http"; +import type { AddressInfo } from "node:net"; +import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest"; +import { agents, authUsers, companies, companyMemberships, companySecretBindings, connectionGrants, createDb, principalPermissionGrants, toolApplications, toolCatalogEntries, toolConnections } from "@paperclipai/db"; +import { and, eq } from "drizzle-orm"; +import { syncConnectionCredentialBindings } from "../services/connection-credential-bindings.js"; +import { connectionManagementService } from "../services/connection-management.js"; +import { secretService } from "../services/secrets.js"; +import { toolAccessService } from "../services/tool-access.js"; +import type { PaperclipCloudConnector } from "../services/paperclip-cloud-connector.js"; +import { startEmbeddedPostgresTestDatabase } from "./helpers/embedded-postgres.js"; + +describe("dedicated agent connection discovery", () => { + let database: Awaited>; + let db: ReturnType; + let provider: Server; + let origin: string; + let requests: Array; + let rejectCredential: boolean; + + beforeAll(async () => { + database = await startEmbeddedPostgresTestDatabase("agent-connection-catalog-"); + db = createDb(database.connectionString); + provider = createServer(async (req, res) => { + if (req.method !== "POST") { res.writeHead(404); res.end(); return; } + const chunks: Buffer[] = []; + for await (const chunk of req) chunks.push(Buffer.from(chunk)); + const message = JSON.parse(Buffer.concat(chunks).toString()); + requests.push(req.headers.authorization); + if (rejectCredential || req.headers.authorization !== "Bearer fixture-agent-access") { + res.writeHead(401, { "www-authenticate": "Bearer", "content-type": "application/json" }); + res.end(JSON.stringify({ error: "unauthorized" })); + return; + } + if (message.method === "notifications/initialized") { + res.writeHead(202); res.end(); return; + } + res.writeHead(200, { "content-type": "application/json" }); + res.end(JSON.stringify({ jsonrpc: "2.0", id: message.id, result: message.method === "initialize" + ? { protocolVersion: "2025-03-26", capabilities: { tools: {} }, serverInfo: { name: "fixture", version: "1" } } + : { tools: [{ name: "get_fixture", description: "Read a fixture", inputSchema: { type: "object" }, annotations: { readOnlyHint: true } }] } })); + }); + await new Promise(resolve => provider.listen(0, "127.0.0.1", resolve)); + origin = `http://127.0.0.1:${(provider.address() as AddressInfo).port}`; + }); + + beforeEach(() => { + requests = []; + rejectCredential = false; + const localFetch = globalThis.fetch; + vi.spyOn(globalThis, "fetch").mockImplementation(async (url, init) => { + const href = String(url); + if (href.startsWith(`${origin}/`)) return localFetch(url, init); + if (href === "https://api.github.com/user") return Response.json({ id: 42, login: "fixture-bot" }); + if (href.startsWith("https://api.github.com/user/installations?")) return Response.json({ installations: [{ id: 101, repository_selection: "selected", account: { login: "example" } }] }); + if (href.startsWith("https://api.github.com/user/installations/101/repositories?")) return Response.json({ total_count: 1, repositories: [{ id: 1, full_name: "example/fixture" }] }); + throw new Error("Unexpected provider request"); + }); + }); + afterEach(() => vi.restoreAllMocks()); + afterAll(async () => { + if (provider) await new Promise(resolve => provider.close(() => resolve())); + await db?.$client.end({ timeout: 1 }); + await database?.cleanup(); + }); + + async function fixture() { + const [company] = await db.insert(companies).values({ name: "Agent catalog fixture", issuePrefix: `AC${randomUUID().slice(0, 6)}` }).returning(); + const [agent, otherAgent] = await db.insert(agents).values(["Owner", "Other"].map(name => ({ companyId: company.id, name, role: "engineer", adapterType: "process" }))).returning(); + const [application] = await db.insert(toolApplications).values({ companyId: company.id, name: "GitHub", type: "mcp_http" }).returning(); + const [connection] = await db.insert(toolConnections).values({ + companyId: company.id, applicationId: application.id, name: "GitHub", uid: randomUUID(), + transport: "mcp_remote", authKind: "oauth", credentialPolicy: "per_agent", status: "active", enabled: true, + healthStatus: "failed", healthMessage: "OAuth credentials have expired and need to be reconnected.", + config: { sourceTemplateKey: "github", url: `${origin}/mcp`, oauth: { + strategy: "paperclip_cloud_connector", provider: "github", connectorProfile: "github.code", + tokenUrl: "https://github.com/login/oauth/access_token", expiresAt: null, + } }, + }).returning(); + const secret = await secretService(db).create(company.id, { name: "Agent access", key: randomUUID(), provider: "local_encrypted", value: "fixture-agent-access" }); + const [grant] = await db.insert(connectionGrants).values({ + companyId: company.id, connectionId: connection.id, kind: "agent", subjectAgentId: agent.id, status: "active", + credentialSecretRefs: [{ secretId: secret.id, configPath: "oauth.access_token", versionSelector: "latest", required: true }], + providerTenant: { oauth: { strategy: "paperclip_cloud_connector", accessTokenExpiresAt: null }, + github: { userId: "42", login: "fixture-bot", installationCount: 1, repositoryCount: 1, repositorySelection: "selected", installationIds: ["101"], installationOwnerLogins: ["example"] } }, + }).returning(); + await syncConnectionCredentialBindings(db, connection); + const connector = { setWebhookBinding: vi.fn(async () => undefined) } as unknown as PaperclipCloudConnector; + const service = toolAccessService(db, { deploymentMode: "local_trusted", deploymentExposure: "private", paperclipCloudConnector: connector }); + return { company, agent, otherAgent, connection, grant, secret, service }; + } + + it.each(["background", "system", "operator", "agent"] as const)("renames and refreshes an agent-owned GitHub connection without reconnect (%s)", async mode => { + const f = await fixture(); + const actor = mode === "background" ? undefined : mode === "system" + ? { actorType: "system" as const } : mode === "operator" + ? { actorType: "user" as const, actorId: "fixture-operator" } + : { actorType: "agent" as const, actorId: f.agent.id }; + await f.service.updateConnection(f.connection.id, { name: "Renamed bot" }); + const refreshed = await f.service.refreshCatalog(f.connection.id, actor); + expect(refreshed.connection).toMatchObject({ name: "Renamed bot", healthStatus: "ok", enabled: true }); + expect((await f.service.getConnection(f.connection.id, f.company.id)).requiresReauthorization).toBe(false); + expect(refreshed.catalog.map(tool => tool.toolName)).toEqual(["get_fixture"]); + expect(requests.length).toBeGreaterThan(0); + expect(requests.every(header => header === "Bearer fixture-agent-access")).toBe(true); + await expect(f.service.checkHealth(f.connection.id, actor)).resolves.toMatchObject({ connection: { healthStatus: "ok" } }); + const [grant] = await db.select().from(connectionGrants).where(eq(connectionGrants.id, f.grant.id)); + expect(grant.status).toBe("active"); + expect(grant.credentialSecretRefs).toEqual(f.grant.credentialSecretRefs); + const bindings = await db.select().from(companySecretBindings).where(and(eq(companySecretBindings.targetId, f.connection.id), eq(companySecretBindings.secretId, f.secret.id))); + expect(bindings).toHaveLength(1); + }); + + describe.each(["refreshCatalog", "checkHealth"] as const)("%s caller isolation", operation => { + it.each(["another agent", "another company", "missing agent identity"])("denies %s without changing the owner's connection", async scope => { + const f = await fixture(); + const actorId = scope === "another company" ? (await fixture()).agent.id : scope === "missing agent identity" ? null : f.otherAgent.id; + await f.service.refreshCatalog(f.connection.id, { actorType: "agent", actorId: f.agent.id }); + const before = await db.select().from(toolConnections).where(eq(toolConnections.id, f.connection.id)); + const catalog = await db.select().from(toolCatalogEntries).where(eq(toolCatalogEntries.connectionId, f.connection.id)); + requests = []; + vi.mocked(fetch).mockClear(); + await expect(f.service[operation](f.connection.id, { actorType: "agent", actorId })) + .rejects.toMatchObject({ status: 422, details: { code: "agent_authorization_required" } }); + expect(requests).toEqual([]); + expect(fetch).not.toHaveBeenCalled(); + expect(await db.select().from(toolConnections).where(eq(toolConnections.id, f.connection.id))).toEqual(before); + expect(await db.select().from(toolCatalogEntries).where(eq(toolCatalogEntries.connectionId, f.connection.id))).toEqual(catalog); + await expect(f.service.checkHealth(f.connection.id, { actorType: "agent", actorId: f.agent.id })) + .resolves.toMatchObject({ connection: { healthStatus: "ok" } }); + }); + + it("keeps the owner's tools healthy when a permitted managing agent lacks the credential", async () => { + const f = await fixture(); + const userId = randomUUID(); + await db.insert(authUsers).values({ id: userId, name: "Manager", email: `${userId}@fixture.invalid`, createdAt: new Date(), updatedAt: new Date() }); + await db.insert(companyMemberships).values([ + { companyId: f.company.id, principalType: "user", principalId: userId, membershipRole: "owner", status: "active" }, + { companyId: f.company.id, principalType: "agent", principalId: f.otherAgent.id, status: "active" }, + ]); + await db.insert(principalPermissionGrants).values([ + { companyId: f.company.id, principalType: "agent", principalId: f.otherAgent.id, permissionKey: "tools:manage_connections" }, + { companyId: f.company.id, principalType: "user", principalId: userId, permissionKey: "tools:manage_connections" }, + ]); + const managementContext = await connectionManagementService(db).authorize({ + type: "agent", agentId: f.otherAgent.id, companyId: f.company.id, onBehalfOfUserId: userId, + }, "connections:configure", { type: "connection_management", companyId: f.company.id, connectionId: f.connection.id, operation }); + expect(managementContext.decision.allowed).toBe(true); + await f.service.refreshCatalog(f.connection.id, { actorType: "agent", actorId: f.agent.id }); + const before = await db.select().from(toolConnections).where(eq(toolConnections.id, f.connection.id)); + requests = []; + vi.mocked(fetch).mockClear(); + await expect(f.service[operation](f.connection.id, { actorType: "agent", actorId: f.otherAgent.id, managementContext })) + .rejects.toMatchObject({ status: 422, details: { code: "agent_authorization_required" } }); + expect(requests).toEqual([]); + expect(fetch).not.toHaveBeenCalled(); + expect(await db.select().from(toolConnections).where(eq(toolConnections.id, f.connection.id))).toEqual(before); + expect((await f.service.listCatalog(f.connection.id, f.company.id)).map(tool => tool.toolName)).toEqual(["get_fixture"]); + }); + }); + + it("does not fall back to personal or organization grants when the agent grant is revoked", async () => { + const f = await fixture(); + await db.update(connectionGrants).set({ status: "revoked" }).where(eq(connectionGrants.id, f.grant.id)); + await db.insert(connectionGrants).values([ + { companyId: f.company.id, connectionId: f.connection.id, kind: "organization", status: "active", isDefault: true, credentialSecretRefs: f.grant.credentialSecretRefs }, + { companyId: f.company.id, connectionId: f.connection.id, kind: "user", subjectUserId: "fixture-operator", status: "active", credentialSecretRefs: f.grant.credentialSecretRefs }, + ]); + await expect(f.service.refreshCatalog(f.connection.id)) + .rejects.toMatchObject({ status: 422, details: { code: "agent_authorization_required" } }); + await expect(f.service.refreshCatalog(f.connection.id, { actorType: "user", actorId: "fixture-operator" })) + .rejects.toMatchObject({ status: 422, details: { code: "agent_authorization_required" } }); + expect((await f.service.getConnection(f.connection.id, f.company.id)).requiresReauthorization).toBe(true); + await expect(f.service.checkHealth(f.connection.id)) + .rejects.toMatchObject({ status: 422, details: { code: "agent_authorization_required" } }); + expect(requests).toEqual([]); + expect(fetch).not.toHaveBeenCalled(); + }); + + it("uses the same agent grant for generic OAuth MCP health and discovery", async () => { + const f = await fixture(); + await f.service.updateConnection(f.connection.id, { config: { url: `${origin}/mcp`, oauth: { + provider: origin, tokenUrl: `${origin}/token`, expiresAt: null, + } } }); + await expect(f.service.refreshCatalog(f.connection.id)).resolves.toMatchObject({ connection: { healthStatus: "ok" } }); + await expect(f.service.checkHealth(f.connection.id)).resolves.toMatchObject({ connection: { healthStatus: "ok" } }); + expect(requests.length).toBeGreaterThan(0); + expect(requests.every(header => header === "Bearer fixture-agent-access")).toBe(true); + }); + + it("does not choose between multiple active agent authorizations in background work", async () => { + const f = await fixture(); + await db.insert(connectionGrants).values({ companyId: f.company.id, connectionId: f.connection.id, + kind: "agent", subjectAgentId: f.otherAgent.id, status: "active", credentialSecretRefs: f.grant.credentialSecretRefs }); + await expect(f.service.refreshCatalog(f.connection.id)) + .rejects.toMatchObject({ status: 422, details: { code: "agent_authorization_ambiguous" } }); + await expect(f.service.checkHealth(f.connection.id)) + .rejects.toMatchObject({ status: 422, details: { code: "agent_authorization_ambiguous" } }); + expect(requests).toEqual([]); + expect(fetch).not.toHaveBeenCalled(); + }); + + it("still requires reconnect when the provider rejects the agent's credential", async () => { + const f = await fixture(); + rejectCredential = true; + await expect(f.service.refreshCatalog(f.connection.id)).rejects.toThrow(); + expect(requests.length).toBeGreaterThan(0); + expect(requests.every(header => header === "Bearer fixture-agent-access")).toBe(true); + const [grant] = await db.select().from(connectionGrants).where(eq(connectionGrants.id, f.grant.id)); + expect(grant.status).toBe("needs_reauthorization"); + expect((await f.service.getConnection(f.connection.id, f.company.id)).requiresReauthorization).toBe(true); + }); +}); diff --git a/server/src/__tests__/github-health-recovery.test.ts b/server/src/__tests__/github-health-recovery.test.ts index 410d6ce7c6c..5cf14b3b99d 100644 --- a/server/src/__tests__/github-health-recovery.test.ts +++ b/server/src/__tests__/github-health-recovery.test.ts @@ -65,6 +65,7 @@ function githubConnectionHealth() { discovery: {} as never, setupPolicy: { assertConnectorConnectionSetupEnabled: async () => undefined } as never, resolveCredentialHeaders: vi.fn() as never, + vaultGrantForConnection: vi.fn() as never, refreshManagedGitHubGrantAccess: (async () => { await loadGitHubGrantMetadata("ghu_secret", suspendedGitHub); }) as never, diff --git a/server/src/__tests__/mcp-tasks-demo-server.test.ts b/server/src/__tests__/mcp-tasks-demo-server.test.ts index 48cdc91519e..ffe1cb95911 100644 --- a/server/src/__tests__/mcp-tasks-demo-server.test.ts +++ b/server/src/__tests__/mcp-tasks-demo-server.test.ts @@ -15,10 +15,12 @@ import { toolMcpTasks, } from "@paperclipai/db"; import { and, eq, lte, ne } from "drizzle-orm"; +import type { AskUserQuestionsPayload } from "@paperclipai/shared"; import { forgetMcpHttpSessions } from "../services/mcp-http.js"; import { createToolGatewayService } from "../services/tool-gateway.js"; import { toolAccessService } from "../services/tool-access.js"; import { instanceSettingsService } from "../services/instance-settings.js"; +import { issueThreadInteractionService } from "../services/issue-thread-interactions.js"; import { adapterExecutionControls, createAdapterExecutionControl } from "../services/adapter-execution-control.js"; import { createTasksDemoHttpServer, @@ -144,11 +146,14 @@ const support = await getEmbeddedPostgresTestSupport(); expect(first).toMatchObject({ reasonCode: "elicitation_required" }); const [card] = await db.select().from(issueThreadInteractions).where(and(eq(issueThreadInteractions.companyId, org.id), eq(issueThreadInteractions.issueId, issue.id))); expect(card).toMatchObject({ kind: "ask_user_questions", status: "pending" }); - await db.update(issueThreadInteractions).set({ status: "answered", result: { version: 1, answers: [ - { questionId: "decision", optionIds: ["approve"] }, + const decision = (card!.payload as unknown as AskUserQuestionsPayload).questions.find((question) => question.id === "decision")!; + const approve = decision.options.find((option) => option.label === "approve"); + expect(approve).toBeDefined(); + await issueThreadInteractionService(db).answerQuestions({ id: issue.id, companyId: org.id }, card!.id, { answers: [ + { questionId: decision.id, optionIds: [approve!.id] }, { questionId: "note", optionIds: [], otherText: "go ahead" }, - ] } }).where(eq(issueThreadInteractions.id, card!.id)); - const pending = call("needs_approval", { action: "rotate the demo key" }); + ] }, { userId: actor.actorId }); + const pending = call("needs_approval", { action: "rotate the demo key" }).catch((error) => error); await vi.waitFor(() => expect(demoTask("needs_approval")?.status).toBe("working"), { timeout: 5_000 }); clock += 3_000; expect(await pending).toMatchObject({ status: "completed", result: { content: "Approved: rotate the demo key was carried out. Note: go ahead" } }); diff --git a/server/src/services/tool-access.ts b/server/src/services/tool-access.ts index cd3f5dd5b1e..7bccdf12de7 100644 --- a/server/src/services/tool-access.ts +++ b/server/src/services/tool-access.ts @@ -803,7 +803,7 @@ export function toolAccessService( const defaultCatalogAccess = createCatalogDefaultAccess(db); const { enableCatalogEntriesByDefault, upsertAskFirstPolicies } = defaultCatalogAccess; const catalogDiscovery = createToolCatalogDiscovery(db, { now, audit, secrets, credentials: credentialAccess, vercel: vercelCredentials, vercelConnect, setupPolicy, requestRemoteHttpEndpoint, resolveOAuthGrantSecret, discoverOAuthEndpoints, localTools }); - const connectionHealth = createConnectionHealth(db, { now, audit, getConnectionRow, discovery: catalogDiscovery, setupPolicy, resolveCredentialHeaders, refreshManagedGitHubGrantAccess, ensureRuntimeSlot, stdioTemplateId }); + const connectionHealth = createConnectionHealth(db, { now, audit, getConnectionRow, discovery: catalogDiscovery, setupPolicy, resolveCredentialHeaders, vaultGrantForConnection, refreshManagedGitHubGrantAccess, ensureRuntimeSlot, stdioTemplateId }); const { updateConnectionHealth, checkConnectionHealth, sweepConnectionHealth } = connectionHealth; const refreshCatalog = createToolCatalogPublication(db, { now, audit, getConnectionRow, discoverTools: catalogDiscovery.discoverTools, discoverSkills: catalogDiscovery.discoverSkills, assertConnectorConnectionSetupEnabled, updateConnectionHealth, vaultGrantForConnection, ensureRuntimeSlot, enableCatalogEntriesByDefault }); const catalogReader = createToolCatalogReader(db, options, now, getConnectionRow, refreshCatalog, toCatalogEntryForConnection); @@ -1065,8 +1065,10 @@ export function toolAccessService( const eligible = grants.filter( (grant) => grant.connectionId === connection.id && - (connection.credentialPolicy !== "per_user" || - (grant.kind === "user" && grant.subjectUserId === userId)), + (connection.credentialPolicy === "per_agent" + ? grant.kind === "agent" + : connection.credentialPolicy !== "per_user" || + (grant.kind === "user" && grant.subjectUserId === userId)), ); connection.requiresReauthorization = !eligible.some( (grant) => grant.status === "active", diff --git a/server/src/services/tool-access/catalog/failures.ts b/server/src/services/tool-access/catalog/failures.ts index 106a3323755..ee7d72bbb5a 100644 --- a/server/src/services/tool-access/catalog/failures.ts +++ b/server/src/services/tool-access/catalog/failures.ts @@ -20,6 +20,12 @@ export function isOAuthEndpointRejection(error: unknown): boolean { return typeof code === "string" && code.endsWith("_endpoint_rejected"); } +/** A caller without an agent grant has not tested the connection's credential. */ +export function isCallerAuthorizationFailure(error: unknown, actor?: ActorInfo): boolean { + return actor?.actorType === "agent" && error instanceof HttpError + && asRecord(error.details).code === "agent_authorization_required"; +} + export function healthFailureHttpStatus(failure: { status: ToolConnectionHealthStatus; code: string; @@ -31,6 +37,7 @@ export function healthFailureHttpStatus(failure: { if (failure.code === "oauth_insufficient_scope") return 422; if (failure.code === "slack_mcp_access_disabled") return 422; if (failure.code === "user_authorization_required") return 422; + if (failure.code === "agent_authorization_required" || failure.code === "agent_authorization_ambiguous") return 422; if (failure.code === "github_installation_required") return 422; if (failure.code === "composio_broker_retired") return 422; if (failure.code === "tool_connection_transport_unsupported") return 422; @@ -62,7 +69,8 @@ export function sanitizeHttpFailure(error: unknown): { if (code === "slack_mcp_access_disabled" || code === "google_workspace_services_unavailable") { return { status: "error", message: error.message, code }; } - if (code === "user_authorization_required" || code === "github_installation_required") { + if (code === "user_authorization_required" || code === "agent_authorization_required" + || code === "agent_authorization_ambiguous" || code === "github_installation_required") { return { status: "error", message: error.message, code }; } if (code === "tool_connection_transport_unsupported") { diff --git a/server/src/services/tool-access/catalog/health.ts b/server/src/services/tool-access/catalog/health.ts index c343d2daf00..2716415199e 100644 --- a/server/src/services/tool-access/catalog/health.ts +++ b/server/src/services/tool-access/catalog/health.ts @@ -21,7 +21,7 @@ import type { ConnectionCredentialAccess } from "../credential-access.js"; import type { ConnectionSetupPolicy } from "../connections/setup-policy.js"; import { toConnection } from "../connections/projection.js"; import { isAgentMailConnection, type ToolCatalogDiscovery } from "./discovery.js"; -import { healthFailureHttpStatus, sanitizeHttpFailure, unreachableServerRemediation, unsupportedToolConnectionTransport } from "./failures.js"; +import { healthFailureHttpStatus, isCallerAuthorizationFailure, sanitizeHttpFailure, unreachableServerRemediation, unsupportedToolConnectionTransport } from "./failures.js"; function asRecord(value: unknown): Record { if (value && typeof value === "object" && !Array.isArray(value)) return value as Record; @@ -35,12 +35,13 @@ type HealthDependencies = { discovery: ToolCatalogDiscovery; setupPolicy: ConnectionSetupPolicy; resolveCredentialHeaders: ConnectionCredentialAccess["resolveCredentialHeaders"]; + vaultGrantForConnection: ConnectionCredentialAccess["vaultGrantForConnection"]; refreshManagedGitHubGrantAccess: ReturnType["refreshManagedGitHubGrantAccess"]; ensureRuntimeSlot: ReturnType["ensureRuntimeSlot"]; stdioTemplateId(companyId: string, config: Record): Promise; }; -export function createConnectionHealth(db: Db, { now, audit, getConnectionRow, discovery, setupPolicy, resolveCredentialHeaders, refreshManagedGitHubGrantAccess, ensureRuntimeSlot, stdioTemplateId }: HealthDependencies) { +export function createConnectionHealth(db: Db, { now, audit, getConnectionRow, discovery, setupPolicy, resolveCredentialHeaders, vaultGrantForConnection, refreshManagedGitHubGrantAccess, ensureRuntimeSlot, stdioTemplateId }: HealthDependencies) { const { discoverTools, remoteTools, validateAgentMailConnection, validateCogneeConnection } = discovery; const { assertConnectorConnectionSetupEnabled } = setupPolicy; async function updateConnectionHealth( @@ -94,7 +95,9 @@ export function createConnectionHealth(db: Db, { now, audit, getConnectionRow, d config.sourceTemplateKey === "github" && oauth.connectorProfile === "github.code" ) { - const activeGrants = await db + const activeGrants = connection.credentialPolicy === "per_agent" + ? [await vaultGrantForConnection(connection, actor)].filter(grant => grant !== null) + : await db .select() .from(connectionGrants) .where( @@ -187,6 +190,7 @@ export function createConnectionHealth(db: Db, { now, audit, getConnectionRow, d }); return { connection: toConnection(updated), runtimeSlot }; } catch (error) { + if (isCallerAuthorizationFailure(error, actor)) throw error; if ( error instanceof HttpError && asRecord(error.details).code === "github_access_changed" diff --git a/server/src/services/tool-access/catalog/publication.ts b/server/src/services/tool-access/catalog/publication.ts index e5e0ab241d5..fb5a2b0911d 100644 --- a/server/src/services/tool-access/catalog/publication.ts +++ b/server/src/services/tool-access/catalog/publication.ts @@ -29,7 +29,7 @@ import { isAgentMailConnection, type ToolCatalogDiscovery } from "./discovery.js import { classifyRisk, shouldQuarantineNewEntries, isGoogleWorkspaceToolAllowed, type McpToolDescriptor } from "./descriptors.js"; import { toConnection } from "../connections/projection.js"; import { toCatalogEntry } from "./projection.js"; -import { healthFailureHttpStatus, sanitizeHttpFailure, unreachableServerRemediation } from "./failures.js"; +import { healthFailureHttpStatus, isCallerAuthorizationFailure, sanitizeHttpFailure, unreachableServerRemediation } from "./failures.js"; function asRecord(value: unknown): Record { if (value && typeof value === "object" && !Array.isArray(value)) return value as Record; @@ -94,6 +94,7 @@ export function createToolCatalogPublication(db: Db, { now, audit, getConnection unavailableServices, ); } catch (error) { + if (isCallerAuthorizationFailure(error, actor)) throw error; if ( error instanceof HttpError && asRecord(error.details).code === "github_access_changed" diff --git a/server/src/services/tool-access/credential-access.ts b/server/src/services/tool-access/credential-access.ts index 65551c7aa30..5fdf4f70901 100644 --- a/server/src/services/tool-access/credential-access.ts +++ b/server/src/services/tool-access/credential-access.ts @@ -39,6 +39,33 @@ export function createConnectionCredentialAccess(db: Db, { secrets, audit, verce connection: typeof toolConnections.$inferSelect, actor?: ActorInfo, ): Promise { + if (connection.credentialPolicy === "per_agent") { + const agentId = actor?.actorType === "agent" ? actor.actorId : null; + if (actor?.actorType === "agent" && !agentId) { + throw unprocessable("This connection needs the agent's authorization", { + code: "agent_authorization_required", + }); + } + // Discovery has no run identity in background/operator work. Use only + // an unambiguous active agent grant; an agent caller must use its own. + const grants = await db.select().from(connectionGrants).where(and( + eq(connectionGrants.companyId, connection.companyId), + eq(connectionGrants.connectionId, connection.id), + eq(connectionGrants.kind, "agent"), + eq(connectionGrants.status, "active"), + ...(agentId ? [eq(connectionGrants.subjectAgentId, agentId)] : []), + )).limit(2); + if (grants.length !== 1) { + throw unprocessable(grants.length > 1 + ? "This connection has multiple agent accounts. Use a separate connection for each agent." + : "This connection needs the agent's authorization", { + code: grants.length > 1 ? "agent_authorization_ambiguous" : "agent_authorization_required", + setupUrl: connectionSetupUrl(connection), + reconnectUrl: connectionReconnectUrl(connection), + }); + } + return grants[0]!; + } const actorUserId = connectionActorUserId(actor); if (actorUserId) {