The open-source app everyone uses to manage agents at work
TypeScript acpxagent-orchestrationagent-skillsagentic-aiai-agentsai-engineeringai-governanceai-toolsautonomous-agentsclaudeclaude-codeclaude-skillscodexhermesllmmcpmulti-agentopenclawproject-managementworkflow-automation
fix(connections): honor identity after reconnect (#12897)
Dottad2d647c34b02
diff --git a/server/src/__tests__/tool-access-service.test.ts b/server/src/__tests__/tool-access-service.test.tsindex 5963fc4105..a5709c0fd2 100644--- a/server/src/__tests__/tool-access-service.test.ts+++ b/server/src/__tests__/tool-access-service.test.ts@@ -5231,6 +5231,113 @@ describeEmbeddedPostgres("tool access service", () => {}});+ it("replaces an archived dedicated GitHub identity with an explicitly selected personal identity", async () => {+ const company = await createCompany(db);+ const userId = `github-personal-revival-${randomUUID()}`;+ await grantBoardUser(db, company.id, userId, [], "owner");+ const agent = await createAgent(db, company.id);+ const connector = fakeGitHubConnector(company.id, `agent:${agent.id}`);+ const originalClaim = connector.claim;+ connector.claim = vi.fn(async (input) => ({+ ...await originalClaim(input),+ subject: input.subject,+ }));+ const service = createTestToolAccessService(db, { paperclipCloudConnector: connector });+ const actor = { actorType: "user" as const, actorId: userId };+ const githubDefinition = getConnectableAppDefinition("github")!;+ const previousOwnershipAvailability = githubDefinition.ownershipAvailability;+ githubDefinition.ownershipAvailability = { ...previousOwnershipAvailability, platform_shared: true };+ vi.spyOn(globalThis, "fetch").mockImplementation(async (url) => {+ const href = String(url);+ if (href === "https://api.github.com/user") {+ return mcpHttpResponse({ id: 42, login: "octocat" });+ }+ if (href.includes("https://api.github.com/user/installations?")) {+ return mcpHttpResponse({ installations: [{+ id: 101,+ repository_selection: "selected",+ html_url: "https://github.com/settings/installations/101",+ account: { login: "paperclipai" },+ }] });+ }+ if (href.includes("https://api.github.com/user/installations/101/repositories?")) {+ return mcpHttpResponse({ total_count: 1, repositories: [] });+ }+ if (href === GITHUB_CONNECTOR_PROFILES["github.code"].serverUrl) {+ return mcpHttpResponse({+ jsonrpc: "2.0",+ id: "paperclip-catalog-refresh",+ result: { tools: [{ name: "get_pull_request", annotations: { readOnlyHint: true } }] },+ });+ }+ throw new Error(`unexpected fetch ${href}`);+ });++ try {+ const dedicated = await service.connectGalleryApp(company.id, {+ galleryKey: "github",+ connectionMethodKey: "managed",+ grantKind: "agent",+ subjectAgentId: agent.id,+ name: "GitHub",+ }, actor);+ const dedicatedStart = await service.startOAuth(company.id, dedicated.connectionId, {+ redirectUri: "https://paperclip.example/api/tools/oauth/cloud-connector/callback",+ actor,+ subjectAgentId: agent.id,+ });+ await service.completePaperclipCloudConnectorCallback({+ state: new URL(dedicatedStart.authorizationUrl).searchParams.get("state")!,+ claimId: "github-dedicated-before-removal",+ actor,+ });+ await service.archiveConnection(dedicated.connectionId, company.id, actor);++ const personal = await service.connectGalleryApp(company.id, {+ galleryKey: "github",+ connectionMethodKey: "managed",+ grantKind: "user",+ name: "GitHub",+ }, actor);+ expect(personal.connectionId).toBe(dedicated.connectionId);+ expect(personal.connection).toMatchObject({+ status: "draft",+ credentialPolicy: "per_user",+ });++ const personalStart = await service.startOAuth(company.id, personal.connectionId, {+ redirectUri: "https://paperclip.example/api/tools/oauth/cloud-connector/callback",+ actor,+ });+ const completed = await service.completePaperclipCloudConnectorCallback({+ state: new URL(personalStart.authorizationUrl).searchParams.get("state")!,+ claimId: "github-personal-after-removal",+ actor,+ });+ expect(completed.connection).toMatchObject({+ status: "active",+ credentialPolicy: "per_user",+ });++ const grants = await service.listConnectionGrants(personal.connectionId, company.id);+ expect(grants.grants).toEqual(expect.arrayContaining([+ expect.objectContaining({+ kind: "agent",+ subjectAgentId: agent.id,+ status: "revoked",+ }),+ expect.objectContaining({+ kind: "user",+ subjectUserId: userId,+ status: "active",+ }),+ ]));+ expect(grants.grants.some((grant) => grant.kind === "organization")).toBe(false);+ } finally {+ githubDefinition.ownershipAvailability = previousOwnershipAvailability;+ }+ });+it("routes a managed Drive callback into the personal vault, filtered catalog, and provider-specific activity", async () => {const company = await createCompany(db);const userId = `drive-member-${randomUUID()}`;@@ -9057,7 +9164,7 @@ describeEmbeddedPostgres("tool access service", () => {}, { actorType: "user", actorId: "board" })).rejects.toMatchObject({ status: 404 });});- it("reuses and revives a removed gallery app without requiring its applicationId", async () => {+ it("reuses a removed gallery app while applying the omitted organization identity default", async () => {const company = await createCompany(db);const service = createTestToolAccessService(db);const actor = { actorType: "user" as const, actorId: "local-board" };@@ -9078,11 +9185,217 @@ describeEmbeddedPostgres("tool access service", () => {expect(second.connectionId).toBe(first.connectionId);expect(second.application.status).toBe("draft");expect(second.connection.status).toBe("draft");- expect(second.connection.credentialPolicy).toBe("per_user");+ expect(second.connection.credentialPolicy).toBe("shared");+ const grants = await service.listConnectionGrants(second.connectionId, company.id);+ expect(grants.grants).toEqual([+ expect.objectContaining({ kind: "organization", status: "active", isDefault: true }),+ ]);await expect(db.select().from(toolApplications)).resolves.toHaveLength(1);await expect(db.select().from(toolConnections)).resolves.toHaveLength(1);});+ it("restores grants and credential policy when an identity-changing revival fails", async () => {+ const company = await createCompany(db);+ const service = createTestToolAccessService(db);+ const actor = {+ actorType: "user" as const,+ actorId: "local-board",+ actorSource: "local_implicit" as const,+ };+ const fetchMock = mockToolsList([+ { name: "get_file_contents", annotations: { readOnlyHint: true } },+ ]);++ const first = await service.connectGalleryApp(company.id, {+ galleryKey: "github",+ connectionMethodKey: "mcp-key",+ grantKind: "organization",+ name: "GitHub rollback",+ credentialValues: { "credentials.authorization": "old-organization-token" },+ }, actor);+ await service.archiveConnection(first.connectionId, company.id, actor);+ const beforeConnection = await service.getConnection(first.connectionId, company.id);+ const beforeGrants = await service.listConnectionGrants(first.connectionId, company.id);+ fetchMock.mockRejectedValue(new Error("provider unavailable"));++ await expect(service.connectGalleryApp(company.id, {+ galleryKey: "github",+ connectionMethodKey: "mcp-key",+ grantKind: "user",+ name: "GitHub rollback",+ credentialValues: { "credentials.authorization": "new-personal-token" },+ }, actor)).rejects.toMatchObject({ status: 502 });++ await expect(service.getConnection(first.connectionId, company.id)).resolves.toMatchObject({+ status: beforeConnection.status,+ credentialPolicy: beforeConnection.credentialPolicy,+ credentialSecretRefs: beforeConnection.credentialSecretRefs,+ });+ const afterGrants = await service.listConnectionGrants(first.connectionId, company.id);+ expect(afterGrants.grants).toEqual(beforeGrants.grants);+ });++ it("preserves a concurrent grant change when an identity-changing revival fails", async () => {+ const company = await createCompany(db);+ const service = createTestToolAccessService(db);+ const actor = {+ actorType: "user" as const,+ actorId: "local-board",+ actorSource: "local_implicit" as const,+ };+ const fetchMock = mockToolsList([+ { name: "get_file_contents", annotations: { readOnlyHint: true } },+ ]);++ const first = await service.connectGalleryApp(company.id, {+ galleryKey: "github",+ connectionMethodKey: "mcp-key",+ grantKind: "organization",+ name: "GitHub concurrent rollback",+ credentialValues: { "credentials.authorization": "old-organization-token" },+ }, actor);+ await service.archiveConnection(first.connectionId, company.id, actor);+ fetchMock.mockImplementation(async () => {+ const [personalGrant] = await db.select().from(connectionGrants).where(and(+ eq(connectionGrants.connectionId, first.connectionId),+ eq(connectionGrants.kind, "user"),+ )).limit(1);+ expect(personalGrant).toBeTruthy();+ const concurrentUpdateAt = new Date(Date.now() + 2_000);+ await db.update(connectionGrants).set({+ status: "revoked",+ credentialSecretRefs: [],+ revokedAt: concurrentUpdateAt,+ updatedAt: concurrentUpdateAt,+ }).where(eq(connectionGrants.id, personalGrant!.id));+ throw new Error("provider unavailable");+ });++ await expect(service.connectGalleryApp(company.id, {+ galleryKey: "github",+ connectionMethodKey: "mcp-key",+ grantKind: "user",+ name: "GitHub concurrent rollback",+ credentialValues: { "credentials.authorization": "new-personal-token" },+ }, actor)).rejects.toMatchObject({ status: 502 });++ await expect(service.getConnection(first.connectionId, company.id)).resolves.toMatchObject({+ status: "archived",+ credentialPolicy: "shared",+ });+ const afterGrants = await service.listConnectionGrants(first.connectionId, company.id);+ expect(afterGrants.grants).toEqual(expect.arrayContaining([+ expect.objectContaining({ kind: "organization", status: "revoked" }),+ expect.objectContaining({ kind: "user", status: "revoked", credentialSecretRefs: [] }),+ ]));+ });++ it("preserves a concurrent connection update when an identity-changing revival fails", async () => {+ const company = await createCompany(db);+ const service = createTestToolAccessService(db);+ const actor = {+ actorType: "user" as const,+ actorId: "local-board",+ actorSource: "local_implicit" as const,+ };+ const fetchMock = mockToolsList([+ { name: "get_file_contents", annotations: { readOnlyHint: true } },+ ]);++ const first = await service.connectGalleryApp(company.id, {+ galleryKey: "github",+ connectionMethodKey: "mcp-key",+ grantKind: "organization",+ name: "GitHub concurrent connection rollback",+ credentialValues: { "credentials.authorization": "old-organization-token" },+ }, actor);+ await service.archiveConnection(first.connectionId, company.id, actor);+ fetchMock.mockImplementation(async () => {+ const concurrentUpdateAt = new Date(Date.now() + 2_000);+ const [connection] = await db.select().from(toolConnections).where(eq(+ toolConnections.id,+ first.connectionId,+ ));+ await db.update(toolConnections).set({+ status: "active",+ enabled: true,+ config: { ...connection.config, concurrentOAuthCompletion: true },+ transportConfig: { ...connection.transportConfig, concurrentOAuthCompletion: true },+ updatedAt: concurrentUpdateAt,+ }).where(eq(toolConnections.id, first.connectionId));+ throw new Error("provider unavailable");+ });++ await expect(service.connectGalleryApp(company.id, {+ galleryKey: "github",+ connectionMethodKey: "mcp-key",+ grantKind: "user",+ name: "GitHub concurrent connection rollback",+ credentialValues: { "credentials.authorization": "new-personal-token" },+ }, actor)).rejects.toMatchObject({ status: 502 });++ await expect(service.getConnection(first.connectionId, company.id)).resolves.toMatchObject({+ status: "active",+ enabled: true,+ credentialPolicy: "per_user",+ config: expect.objectContaining({ concurrentOAuthCompletion: true }),+ });+ const afterGrants = await service.listConnectionGrants(first.connectionId, company.id);+ const personalGrant = afterGrants.grants.find((grant) => grant.kind === "user");+ expect(personalGrant).toMatchObject({ status: "active" });+ expect(personalGrant?.credentialSecretRefs).toHaveLength(1);+ const [preservedSecret] = await db.select().from(companySecrets).where(eq(+ companySecrets.id,+ personalGrant!.credentialSecretRefs[0]!.secretId,+ ));+ expect(preservedSecret.deletedAt).toBeNull();+ });++ it("fails closed when an identity-changing revival cannot roll back", async () => {+ const company = await createCompany(db);+ const service = createTestToolAccessService(db);+ const actor = {+ actorType: "user" as const,+ actorId: "local-board",+ actorSource: "local_implicit" as const,+ };+ const fetchMock = mockToolsList([+ { name: "get_file_contents", annotations: { readOnlyHint: true } },+ ]);++ const first = await service.connectGalleryApp(company.id, {+ galleryKey: "github",+ connectionMethodKey: "mcp-key",+ grantKind: "organization",+ name: "GitHub rollback failure",+ credentialValues: { "credentials.authorization": "old-organization-token" },+ }, actor);+ await service.archiveConnection(first.connectionId, company.id, actor);+ fetchMock.mockRejectedValue(new Error("provider unavailable"));+ const runTransaction = db.transaction.bind(db);+ vi.spyOn(db, "transaction")+ .mockImplementationOnce(runTransaction)+ .mockRejectedValueOnce(new Error("rollback unavailable"));++ await expect(service.connectGalleryApp(company.id, {+ galleryKey: "github",+ connectionMethodKey: "mcp-key",+ grantKind: "user",+ name: "GitHub rollback failure",+ credentialValues: { "credentials.authorization": "new-personal-token" },+ }, actor)).rejects.toMatchObject({+ status: 500,+ details: { code: "connection_identity_rollback_failed" },+ });++ await expect(service.getConnection(first.connectionId, company.id)).resolves.toMatchObject({+ status: "draft",+ enabled: false,+ healthStatus: "error",+ lastError: "connection_identity_rollback_failed",+ });+ });+it("automatically gives same-named connections distinct names", async () => {const company = await createCompany(db);const service = createTestToolAccessService(db);diff --git a/server/src/services/tool-access.ts b/server/src/services/tool-access.tsindex 6d55ae9357..284b3510f2 100644--- a/server/src/services/tool-access.ts+++ b/server/src/services/tool-access.ts@@ -1769,6 +1769,22 @@ function stableHash(value: unknown): string {return createHash("sha256").update(JSON.stringify(value, Object.keys(flattenKeys(value)).sort())).digest("hex");}+function connectionSetupMutationFingerprint(row: typeof toolConnections.$inferSelect): string {+ return stableHash({+ name: row.name,+ transport: row.transport,+ status: row.status,+ enabled: row.enabled,+ config: row.config,+ transportConfig: row.transportConfig,+ credentialRefs: row.credentialRefs,+ credentialSecretRefs: row.credentialSecretRefs,+ credentialSource: row.credentialSource,+ externalCredential: row.externalCredential,+ credentialPolicy: row.credentialPolicy,+ });+}+function flattenKeys(value: unknown, keys: Record<string, true> = {}): Record<string, true> {if (value && typeof value === "object") {for (const [key, nested] of Object.entries(value as Record<string, unknown>)) {@@ -3897,6 +3913,10 @@ export function toolAccessService(db: Db, options: ToolAccessServiceOptions = {}async function ensureDefaultOrganizationGrant(connection: typeof toolConnections.$inferSelect,dbClient: ToolAccessMutationDb = db,+ onMutation?: (mutation: {+ previous: typeof connectionGrants.$inferSelect | null;+ current: typeof connectionGrants.$inferSelect;+ }) => void,) {const [existing] = await dbClient.select()@@ -3929,6 +3949,7 @@ export function toolAccessService(db: Db, options: ToolAccessServiceOptions = {}.where(eq(connectionGrants.id, existing.id)).returning();if (!updated) throw new Error("Failed to update default connection grant");+ onMutation?.({ previous: existing, current: updated });return updated;}const [created] = await dbClient@@ -3943,6 +3964,7 @@ export function toolAccessService(db: Db, options: ToolAccessServiceOptions = {}}).returning();if (!created) throw new Error("Failed to create default connection grant");+ onMutation?.({ previous: null, current: created });return created;}@@ -8830,13 +8852,29 @@ export function toolAccessService(db: Db, options: ToolAccessServiceOptions = {}));name = nextAvailableConnectionName(requestedName, connectionNames.map((row) => row.name));}- const retainedGrantKind: ConnectionGrantKind | null = retainedConnection+ const previousGrantKind: ConnectionGrantKind | null = retainedConnection? retainedConnection.credentialPolicy === "per_user"? "user": retainedConnection.credentialPolicy === "per_agent"? "agent": "organization": null;+ // An explicit resume/application reconnect continues the retained identity.+ // A fresh gallery connect may still reuse an archived row for stable history+ // and company-unique naming, but an explicit Access choice is a new identity+ // decision and must replace the archived policy. Without this distinction,+ // removing a dedicated-agent connection and reconnecting the default personal+ // account leaves `per_agent` behind and the OAuth callback cannot persist its+ // user grant.+ const retainsIdentity = Boolean(+ retainedConnection+ && (+ retainedConnection.status === "draft"+ || requestedResumeConnection+ || input.applicationId+ )+ );+ const retainedGrantKind = retainsIdentity ? previousGrantKind : null;// The route can authorize an explicit resume before entering the service,// but name/source recovery happens here. Do not let a caller submit a// personal grant choice to pass the route and then inherit an implicitly@@ -8844,8 +8882,9 @@ export function toolAccessService(db: Db, options: ToolAccessServiceOptions = {}// unrestricted instance operator; every authenticated user must still hold// current connection-manager authority before this retained row is touched.if (- retainedGrantKind === "organization"- && input.grantKind === "user"+ previousGrantKind+ && input.grantKind+ && previousGrantKind !== input.grantKind&& actor?.actorType === "user"&& actor.actorSource !== "local_implicit") {@@ -8868,7 +8907,7 @@ export function toolAccessService(db: Db, options: ToolAccessServiceOptions = {}eq(principalPermissionGrants.permissionKey, "tools:manage_connections"),)).limit(1);if (!roleCanManage && !explicitManagerGrant) {- throw forbidden("Only a company owner, admin, or member with connection-manager permission can share credentials with the organization.");+ throw forbidden("Only a company owner, admin, or member with connection-manager permission can change this connection's credential identity.");}}const requestedGrantKind = retainedGrantKind ?? input.grantKind ?? "organization";@@ -9069,6 +9108,7 @@ export function toolAccessService(db: Db, options: ToolAccessServiceOptions = {}// or API key, without carrying credentials across a method/provider change.const canRetainCredentialMaterial = Boolean(retainedConnection+ && previousGrantKind === requestedGrantKind&& galleryEntry&& retainedSource === galleryEntry.slug&& retainedMethodKey === method?.key,@@ -9076,17 +9116,19 @@ export function toolAccessService(db: Db, options: ToolAccessServiceOptions = {}const retainedCredentialSecretRefs = canRetainCredentialMaterial? (retainedPersonalIdentity?.grant?.credentialSecretRefs ?? retainedConnection?.credentialSecretRefs ?? []): [];- // Only the personal path changes the policy; every existing gallery app keeps- // the shared default it has today.- const credentialPolicy: ToolConnectionCredentialPolicy | undefined = personalIdentityUserId+ const credentialPolicy: ToolConnectionCredentialPolicy = requestedGrantKind === "user"? "per_user"- : dedicatedAgentId+ : requestedGrantKind === "agent"? "per_agent"- : undefined;+ : "shared";const connectionOwnership = isPaperclipCloudConnectorStrategy(method?.oauthStrategy) ? "platform_shared" : "customer";let applicationRow: typeof toolApplications.$inferSelect | null = null;let connectionRow: typeof toolConnections.$inferSelect | null = null;let revivedConnectionPrevious: typeof toolConnections.$inferSelect | null = retainedConnection ?? null;+ let revivedGrantMutation: {+ previous: typeof connectionGrants.$inferSelect | null;+ current: typeof connectionGrants.$inferSelect;+ } | null = null;try {const credentialFields = credentialSource === "vercel_connect"@@ -9273,9 +9315,7 @@ export function toolAccessService(db: Db, options: ToolAccessServiceOptions = {}credentialSecretRefs: connectionCredentialSecretRefs,credentialSource,externalCredential,- // Identity is immutable for a retained connection. A fresh- // connection still derives it from the explicit Access choice.- credentialPolicy: revivedConnectionPrevious.credentialPolicy,+ credentialPolicy,updatedAt: new Date(),}).where(eq(toolConnections.id, revivedConnectionPrevious.id)).returning();} else {@@ -9298,7 +9338,7 @@ export function toolAccessService(db: Db, options: ToolAccessServiceOptions = {}transportConfig: config,credentialRefs,credentialSecretRefs: connectionCredentialSecretRefs,- ...(credentialPolicy ? { credentialPolicy } : {}),+ credentialPolicy,createdByAgentId: actor?.actorType === "agent" ? actor.actorId ?? null : null,createdByUserId: actor?.actorType === "user" ? actor.actorId ?? null : null,}).returning();@@ -9323,17 +9363,29 @@ export function toolAccessService(db: Db, options: ToolAccessServiceOptions = {}// "Connected" with nothing behind it, so the grant is left to the// callback and only the organization grant is suppressed.if (credentialSecretRefs.length > 0) {+ let changedGrant: typeof connectionGrants.$inferSelect;+ let previousGrant: typeof connectionGrants.$inferSelect | null = null;if (retainedPersonalIdentity?.grant) {- await db.update(connectionGrants).set({+ const [currentGrant] = await db.select().from(connectionGrants).where(eq(+ connectionGrants.id,+ retainedPersonalIdentity.grant.id,+ )).limit(1);+ if (!currentGrant) throw conflict("The personal credential changed during setup. Please try again.");+ previousGrant = currentGrant;+ [changedGrant] = await db.update(connectionGrants).set({credentialSecretRefs,status: "active",revokedAt: null,revokedByAgentId: null,revokedByUserId: null,updatedAt: new Date(),- }).where(eq(connectionGrants.id, retainedPersonalIdentity.grant.id));+ }).where(and(+ eq(connectionGrants.id, currentGrant.id),+ eq(connectionGrants.updatedAt, currentGrant.updatedAt),+ )).returning();+ if (!changedGrant) throw conflict("The personal credential changed during setup. Please try again.");} else {- await db.insert(connectionGrants).values({+ [changedGrant] = await db.insert(connectionGrants).values({companyId,connectionId: connectionRow.id,kind: "user",@@ -9342,7 +9394,11 @@ export function toolAccessService(db: Db, options: ToolAccessServiceOptions = {}status: "active",isDefault: false,createdByUserId: personalIdentityUserId,- });+ }).returning();+ if (!changedGrant) throw new Error("Failed to create personal connection grant");+ }+ if (revivedConnectionPrevious) {+ revivedGrantMutation = { previous: previousGrant, current: changedGrant };}await db.insert(toolAccessAuditEvents).values({companyId,@@ -9361,7 +9417,15 @@ export function toolAccessService(db: Db, options: ToolAccessServiceOptions = {}// Managed OAuth creates the credential-bearing grant in the callback.// Keep the connection free of organization secrets from the outset.} else {- await ensureDefaultOrganizationGrant(connectionRow);+ const organizationGrant = await ensureDefaultOrganizationGrant(+ connectionRow,+ db,+ revivedConnectionPrevious+ ? (mutation) => {+ revivedGrantMutation = mutation;+ }+ : undefined,+ );if (credentialSource === "vercel_connect") {const derived = deriveVercelConnectSubject({credential: externalCredential!,@@ -9369,20 +9433,37 @@ export function toolAccessService(db: Db, options: ToolAccessServiceOptions = {}companyId,grantKind: "organization",});- await db.update(connectionGrants).set({- externalCredential: {- provider: "vercel_connect",- subjectType: externalCredential!.principalMode,- ...(derived.subjectId ? { subjectId: derived.subjectId } : {}),- },- credentialSecretRefs: [],- updatedAt: now(),- }).where(and(- eq(connectionGrants.companyId, companyId),- eq(connectionGrants.connectionId, connectionRow.id),- eq(connectionGrants.kind, "organization"),- eq(connectionGrants.isDefault, true),- ));+ const updatedOrganizationGrant = await db.transaction(async (tx) => {+ const [lockedGrant] = await tx.select().from(connectionGrants).where(eq(+ connectionGrants.id,+ organizationGrant.id,+ )).limit(1).for("update");+ if (+ !lockedGrant+ || lockedGrant.updatedAt.getTime() !== organizationGrant.updatedAt.getTime()+ ) {+ throw conflict("The organization credential changed during setup. Please try again.");+ }+ const [updated] = await tx.update(connectionGrants).set({+ externalCredential: {+ provider: "vercel_connect",+ subjectType: externalCredential!.principalMode,+ ...(derived.subjectId ? { subjectId: derived.subjectId } : {}),+ },+ credentialSecretRefs: [],+ updatedAt: now(),+ }).where(eq(connectionGrants.id, organizationGrant.id)).returning();+ return updated;+ });+ if (!updatedOrganizationGrant) {+ throw conflict("The organization credential changed during setup. Please try again.");+ }+ if (revivedGrantMutation) {+ revivedGrantMutation = {+ previous: revivedGrantMutation.previous,+ current: updatedOrganizationGrant,+ };+ }}}await syncCredentialBindings(connectionRow, personalIdentityUserId || dedicatedAgentId ? credentialSecretRefs : []);@@ -9472,33 +9553,131 @@ export function toolAccessService(db: Db, options: ToolAccessServiceOptions = {}},};} catch (error) {+ let identityRollbackError: unknown = null;+ let preserveConcurrentRevival = false;if (connectionRow && revivedConnectionPrevious) {- await db.update(toolConnections).set({- name: revivedConnectionPrevious.name,- transport: revivedConnectionPrevious.transport,- status: revivedConnectionPrevious.status,- enabled: revivedConnectionPrevious.enabled,- config: revivedConnectionPrevious.config,- transportConfig: revivedConnectionPrevious.transportConfig,- credentialRefs: revivedConnectionPrevious.credentialRefs,- credentialSecretRefs: revivedConnectionPrevious.credentialSecretRefs,- credentialSource: revivedConnectionPrevious.credentialSource,- externalCredential: revivedConnectionPrevious.externalCredential,- updatedAt: new Date(),- }).where(eq(toolConnections.id, revivedConnectionPrevious.id)).catch(() => undefined);+ const attemptedConnection = connectionRow;+ try {+ await db.transaction(async (tx) => {+ const [latestConnection] = await tx.select().from(toolConnections).where(and(+ eq(toolConnections.id, revivedConnectionPrevious.id),+ eq(toolConnections.companyId, companyId),+ )).limit(1).for("update");+ // Health/catalog failures from this setup may update only health+ // fields and `updatedAt`, so compare the identity/configuration+ // fields this attempt owned. If another request changed any of+ // those fields, its newer connection state is authoritative.+ const connectionMutationIsStillCurrent = Boolean(+ latestConnection+ && connectionSetupMutationFingerprint(latestConnection)+ === connectionSetupMutationFingerprint(attemptedConnection),+ );+ if (connectionMutationIsStillCurrent) {+ await tx.update(toolConnections).set({+ name: revivedConnectionPrevious.name,+ transport: revivedConnectionPrevious.transport,+ status: revivedConnectionPrevious.status,+ enabled: revivedConnectionPrevious.enabled,+ config: revivedConnectionPrevious.config,+ transportConfig: revivedConnectionPrevious.transportConfig,+ credentialRefs: revivedConnectionPrevious.credentialRefs,+ credentialSecretRefs: revivedConnectionPrevious.credentialSecretRefs,+ credentialSource: revivedConnectionPrevious.credentialSource,+ externalCredential: revivedConnectionPrevious.externalCredential,+ credentialPolicy: revivedConnectionPrevious.credentialPolicy,+ updatedAt: new Date(),+ }).where(eq(toolConnections.id, revivedConnectionPrevious.id));+ } else {+ preserveConcurrentRevival = true;+ }++ if (connectionMutationIsStillCurrent && revivedGrantMutation) {+ const { previous, current } = revivedGrantMutation;+ const [latestGrant] = await tx.select().from(connectionGrants).where(eq(+ connectionGrants.id,+ current.id,+ )).limit(1).for("update");+ const mutationIsStillCurrent = Boolean(+ latestGrant+ && latestGrant.updatedAt.getTime() === current.updatedAt.getTime(),+ );+ // A grant manager may have changed this grant while provider+ // setup was in flight. Restore/delete only the exact version this+ // attempt wrote; a newer version is authoritative and remains+ // untouched.+ if (previous && mutationIsStillCurrent) {+ await tx.update(connectionGrants).set({+ kind: previous.kind,+ subjectUserId: previous.subjectUserId,+ subjectAgentId: previous.subjectAgentId,+ providerTenant: previous.providerTenant,+ credentialSecretRefs: previous.credentialSecretRefs,+ externalCredential: previous.externalCredential,+ status: previous.status,+ isDefault: previous.isDefault,+ createdByAgentId: previous.createdByAgentId,+ createdByUserId: previous.createdByUserId,+ revokedAt: previous.revokedAt,+ revokedByAgentId: previous.revokedByAgentId,+ revokedByUserId: previous.revokedByUserId,+ lastUsedAt: previous.lastUsedAt,+ updatedAt: previous.updatedAt,+ }).where(eq(connectionGrants.id, current.id));+ } else if (!previous && mutationIsStillCurrent) {+ await tx.delete(connectionGrants).where(eq(connectionGrants.id, current.id));+ }+ }+ });+ } catch (rollbackError) {+ identityRollbackError = rollbackError;+ // The attempted identity and its grants may no longer agree. Keep the+ // connection unusable until a manager explicitly reconnects it, and+ // surface the restoration failure instead of returning only the+ // original provider error.+ try {+ await db.update(toolConnections).set({+ status: "draft",+ enabled: false,+ healthStatus: "error",+ healthMessage: "Connection identity restoration failed. Reconnect this app to continue.",+ lastError: "connection_identity_rollback_failed",+ updatedAt: new Date(),+ }).where(and(+ eq(toolConnections.id, revivedConnectionPrevious.id),+ eq(toolConnections.companyId, companyId),+ ));+ } catch (quarantineError) {+ identityRollbackError = new AggregateError(+ [rollbackError, quarantineError],+ "Connection identity rollback and quarantine both failed",+ );+ }+ }} else if (connectionRow) {await db.delete(toolConnections).where(eq(toolConnections.id, connectionRow.id)).catch(() => undefined);}- if (applicationRow && !existingApplication) {+ if (!preserveConcurrentRevival && applicationRow && !existingApplication) {await db.delete(toolApplications).where(eq(toolApplications.id, applicationRow.id)).catch(() => undefined);- } else if (existingApplication && applicationRow && applicationRow.status !== existingApplication.status) {+ } else if (+ !preserveConcurrentRevival+ && existingApplication+ && applicationRow+ && applicationRow.status !== existingApplication.status+ ) {await db.update(toolApplications).set({ status: existingApplication.status, archivedAt: existingApplication.archivedAt, updatedAt: new Date() }).where(eq(toolApplications.id, existingApplication.id)).catch(() => undefined);}- for (const secretId of createdSecretIds) {- await secrets.remove(secretId).catch(() => undefined);+ if (!preserveConcurrentRevival) {+ for (const secretId of createdSecretIds) {+ await secrets.remove(secretId).catch(() => undefined);+ }+ }+ if (identityRollbackError) {+ throw new HttpError(500, "Connection setup failed and its prior identity could not be restored.", {+ code: "connection_identity_rollback_failed",+ });}throw error;}