@rudderhq/server 0.5.2-canary.2 → 0.6.0

package/dist/services/mcp/managed-connections.js

@@ -0,0 +1,920 @@
+import { activityLog, customIntegrationTools, mcpConnections, mcpOAuthGrants, organizationSecrets, organizationSecretVersions, } from "@rudderhq/db";
+import { createMcpConnectionSchema, MCP_PROVIDER_CATALOG, mcpConnectionMergedConfigSchema, mcpConnectionMutationConfigSchema, updateMcpConnectionSchema, } from "@rudderhq/shared";
+import { and, asc, eq, sql } from "drizzle-orm";
+import { randomUUID } from "node:crypto";
+import { conflict, HttpError, notFound, unprocessable } from "../../errors.js";
+import { getSecretProvider } from "../../secrets/provider-registry.js";
+import { secretService } from "../secrets.js";
+import { createManagedMcpClient, resolveMcpHttpCredentials, } from "./managed-client.js";
+import { MCP_PROVIDER_REGISTRY, resolveCuratedMcpEndpoint, } from "./provider-registry.js";
+import { assertSafeMcpCredentialHeaders, assertSafeMcpHeaders, resolveMcpHttpTarget, validateMcpStdioPolicy, } from "./security-policy.js";
+import { normalizeMcpDiscoveredTools, reconcileMcpToolCatalog, } from "./tool-discovery.js";
+const EMPTY_ALLOWLISTS = {
+    httpOrigins: [],
+    stdioCommands: [],
+    stdioWorkingDirectories: [],
+    stdioEnvironmentNames: [],
+};
+const SENSITIVE_STATIC_NAME_RE = /(api[-_]?key|client[-_]?key|access[-_]?token|auth(?:[-_]?token)?|authorization|bearer|secret|passwd|password|credential|cookie|jwt|private[-_]?key|connectionstring|(?:^|[-_])(?:token|key)(?:$|[-_]))/iu;
+const RECONNECT_REQUIRED_STATUSES = new Set([
+    "disabled",
+    "revoked",
+    "needs_reauth",
+    "error",
+]);
+export class ManagedMcpConnectionPolicyError extends HttpError {
+    code = "managed_mcp_policy_rejected";
+    constructor(message = "Managed MCP connection policy rejected the configuration") {
+        super(422, message);
+        this.name = "ManagedMcpConnectionPolicyError";
+    }
+}
+export class ManagedMcpDiscoveryStaleError extends HttpError {
+    code = "managed_mcp_discovery_stale";
+    constructor() {
+        super(409, "Managed MCP connection changed while tools were being discovered");
+        this.name = "ManagedMcpDiscoveryStaleError";
+    }
+}
+function discoverySnapshot(row) {
+    return {
+        enabled: row.enabled,
+        lastDiscoveredAt: row.lastDiscoveredAt?.getTime() ?? null,
+        lifecycleRevision: row.lifecycleRevision,
+        status: row.status,
+        updatedAt: row.updatedAt.getTime(),
+    };
+}
+function nextConnectionMutationTime(row) {
+    return new Date(Math.max(Date.now(), row.updatedAt.getTime() + 1));
+}
+function assertDiscoverySnapshot(row, snapshot) {
+    if (row.enabled !== snapshot.enabled
+        || row.lifecycleRevision !== snapshot.lifecycleRevision
+        || row.status !== snapshot.status
+        || row.updatedAt.getTime() !== snapshot.updatedAt
+        || (row.lastDiscoveredAt?.getTime() ?? null) !== snapshot.lastDiscoveredAt) {
+        throw new ManagedMcpDiscoveryStaleError();
+    }
+}
+function managedMcpActivityValues(input) {
+    const actorType = input.actor.agentId
+        ? "agent"
+        : input.actor.userId
+            ? "user"
+            : "system";
+    const actorId = input.actor.agentId ?? input.actor.userId ?? "system";
+    return {
+        orgId: input.orgId,
+        actorType,
+        actorId,
+        action: input.action,
+        entityType: "mcp_connection",
+        entityId: input.connectionId,
+        agentId: input.actor.agentId ?? null,
+        details: input.details,
+    };
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function asStdioConfig(config) {
+    return config;
+}
+function asHttpConfig(config) {
+    return config;
+}
+function discoveryFilter(row) {
+    if (row.provider !== "custom")
+        return {};
+    const config = row.transport === "stdio"
+        ? asStdioConfig(row.safeConfig)
+        : asHttpConfig(row.safeConfig);
+    return {
+        toolAllowlist: config.toolAllowlist,
+        toolDenylist: config.toolDenylist,
+    };
+}
+function declaredSecretShape(transport, safeConfig) {
+    if (transport === "stdio") {
+        const config = asStdioConfig(safeConfig);
+        return {
+            env: [...(config.secretEnvNames ?? [])].sort(),
+            headers: [],
+            bearerToken: false,
+        };
+    }
+    if (transport === "streamable_http") {
+        const config = asHttpConfig(safeConfig);
+        return {
+            env: [],
+            headers: [...(config.secretHeaderNames ?? [])]
+                .map((name) => name.toLowerCase())
+                .sort(),
+            bearerToken: config.hasBearerToken === true,
+        };
+    }
+    return { env: [], headers: [], bearerToken: false };
+}
+function equalSecretShape(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}
+function hasDeclaredSecrets(shape) {
+    return shape.env.length > 0 || shape.headers.length > 0 || shape.bearerToken;
+}
+function assertNoSensitiveStaticNames(values, kind) {
+    const sensitiveName = Object.keys(values ?? {}).find((name) => (SENSITIVE_STATIC_NAME_RE.test(name)));
+    if (sensitiveName) {
+        throw new ManagedMcpConnectionPolicyError(`Managed MCP static ${kind} names that look sensitive must use encrypted credentials`);
+    }
+}
+function assertCustomHttpHeaderPolicy(config, credentials) {
+    try {
+        assertSafeMcpHeaders(config.staticHeaders ?? {});
+        assertSafeMcpCredentialHeaders(Object.fromEntries(Object.keys(config.headersFromEnv ?? {}).map((name) => [name, "environment-reference"])));
+        assertSafeMcpCredentialHeaders(Object.fromEntries((config.secretHeaderNames ?? []).map((name) => [name, "encrypted-reference"])));
+        if (credentials?.headers) {
+            assertSafeMcpCredentialHeaders(credentials.headers);
+        }
+    }
+    catch {
+        throw new ManagedMcpConnectionPolicyError("Managed MCP header configuration is rejected by deployment policy");
+    }
+    assertNoSensitiveStaticNames(config.staticHeaders, "header");
+}
+function reconnectRequiredError() {
+    return unprocessable("Reconnect the managed MCP connection before enabling or discovering tools");
+}
+function discoveryNotReadyError() {
+    return unprocessable("Managed MCP connection is not ready for tool discovery; reconnect or complete authorization first");
+}
+function canDiscoverTools(row) {
+    if (!row.enabled)
+        return false;
+    if (row.provider === "custom") {
+        return row.status === "draft" || row.status === "active";
+    }
+    return row.status === "active";
+}
+function publicSummary(row) {
+    return {
+        id: row.id,
+        orgId: row.orgId,
+        name: row.name,
+        displayName: row.displayName,
+        provider: row.provider,
+        transport: row.transport,
+        externalScope: row.externalScope,
+        accessMode: row.accessMode,
+        status: row.status,
+        safeConfig: row.safeConfig,
+        startupTimeoutMs: row.startupTimeoutMs,
+        toolTimeoutMs: row.toolTimeoutMs,
+        enabled: row.enabled,
+        required: row.required,
+        hasCredentials: Boolean(row.credentialSecretId),
+        lastDiscoveredAt: row.lastDiscoveredAt,
+        activatedAt: row.activatedAt,
+        disabledAt: row.disabledAt,
+        revokedAt: row.revokedAt,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+    };
+}
+function publicTool(row) {
+    if (!row.connectionId) {
+        throw new Error("Managed MCP tool is missing its connection");
+    }
+    return {
+        id: row.id,
+        connectionId: row.connectionId,
+        externalToolName: row.externalToolName,
+        rudderToolName: row.rudderToolName,
+        description: row.description,
+        inputSchema: row.inputSchema,
+        outputSchema: row.outputSchema,
+        enabled: row.enabled,
+        removedAt: row.removedAt,
+    };
+}
+function parseCredentialPayload(value) {
+    try {
+        const parsed = JSON.parse(value);
+        if (!isRecord(parsed))
+            throw new Error("invalid");
+        return {
+            env: isRecord(parsed.env)
+                ? Object.fromEntries(Object.entries(parsed.env).filter((entry) => (typeof entry[1] === "string")))
+                : undefined,
+            headers: isRecord(parsed.headers)
+                ? Object.fromEntries(Object.entries(parsed.headers).filter((entry) => (typeof entry[1] === "string")))
+                : undefined,
+            bearerToken: typeof parsed.bearerToken === "string" ? parsed.bearerToken : undefined,
+        };
+    }
+    catch {
+        throw unprocessable("Managed MCP credential material is invalid");
+    }
+}
+function customSecretPayload(input) {
+    return {
+        ...(input.env ? { env: input.env } : {}),
+        ...(input.headers ? { headers: input.headers } : {}),
+        ...(input.bearerToken ? { bearerToken: input.bearerToken } : {}),
+    };
+}
+function assertLegacyMutable(row) {
+    if (row.transport === "legacy_manual") {
+        throw unprocessable("Legacy manual MCP definitions are read-only; create and reconnect a new managed connection");
+    }
+}
+function redactedDiscoveryError() {
+    return unprocessable("Managed MCP tool discovery failed");
+}
+export function managedMcpConnectionService(db, options) {
+    const secrets = secretService(db);
+    const createClient = options.createClient ?? createManagedMcpClient;
+    const hostEnv = options.hostEnv ?? process.env;
+    const allowlists = options.allowlists ?? EMPTY_ALLOWLISTS;
+    async function findRow(orgId, connectionId) {
+        const row = await db
+            .select()
+            .from(mcpConnections)
+            .where(and(eq(mcpConnections.orgId, orgId), eq(mcpConnections.id, connectionId)))
+            .then((rows) => rows[0] ?? null);
+        if (!row)
+            throw notFound("MCP connection not found");
+        return row;
+    }
+    function assertHttpEnvironmentPolicy(config) {
+        if (options.deploymentMode !== "authenticated")
+            return;
+        const allowed = new Set(allowlists.stdioEnvironmentNames);
+        const requested = [
+            ...Object.values(config.headersFromEnv ?? {}),
+            ...(config.bearerTokenEnvVar ? [config.bearerTokenEnvVar] : []),
+        ];
+        if (requested.some((name) => !allowed.has(name))) {
+            throw unprocessable("Managed MCP HTTP environment name is not allowed by deployment policy");
+        }
+    }
+    async function validateBoundary(input) {
+        try {
+            if (input.transport === "legacy_manual")
+                return;
+            if (input.transport === "stdio") {
+                const config = asStdioConfig(input.safeConfig);
+                assertNoSensitiveStaticNames(config.staticEnv, "environment variable");
+                await validateMcpStdioPolicy({
+                    command: config.command,
+                    args: config.args,
+                    cwd: config.cwd,
+                    environmentNames: [
+                        ...Object.keys(config.staticEnv ?? {}),
+                        ...(config.forwardedEnv ?? []),
+                        ...(config.secretEnvNames ?? []),
+                    ],
+                }, {
+                    deploymentMode: options.deploymentMode,
+                    stdioCommands: allowlists.stdioCommands,
+                    stdioWorkingDirectories: allowlists.stdioWorkingDirectories,
+                    stdioEnvironmentNames: allowlists.stdioEnvironmentNames,
+                });
+                return;
+            }
+            let url;
+            let curatedOrigin;
+            if (input.provider === "custom") {
+                const config = asHttpConfig(input.safeConfig);
+                if (!config.url)
+                    throw unprocessable("Custom Streamable HTTP connection requires a URL");
+                assertCustomHttpHeaderPolicy(config, input.credentials);
+                assertHttpEnvironmentPolicy(config);
+                url = config.url;
+            }
+            else {
+                // Supabase is allowed to remain draft before project selection.
+                if (input.provider === "supabase" && !input.externalScope) {
+                    return;
+                }
+                const endpoint = resolveCuratedMcpEndpoint({
+                    provider: input.provider,
+                    accessMode: input.accessMode,
+                    externalScope: input.externalScope,
+                });
+                url = endpoint.href;
+                curatedOrigin = new URL(MCP_PROVIDER_REGISTRY[input.provider].endpoint).origin;
+            }
+            await resolveMcpHttpTarget(url, {
+                allowedOrigins: allowlists.httpOrigins,
+                curatedOrigin,
+                lookup: options.dnsLookup,
+            });
+        }
+        catch (error) {
+            if (error instanceof HttpError) {
+                throw error;
+            }
+            throw new ManagedMcpConnectionPolicyError();
+        }
+    }
+    async function prepareCredentialReplacement(connectionName, value) {
+        const id = randomUUID();
+        const prepared = await getSecretProvider("local_encrypted").createVersion({
+            value: JSON.stringify(customSecretPayload(value)),
+            externalRef: null,
+        });
+        return {
+            id,
+            name: `Managed MCP credentials - ${connectionName} - ${id}`,
+            externalRef: prepared.externalRef,
+            material: prepared.material,
+            valueSha256: prepared.valueSha256,
+        };
+    }
+    async function resolveCredentialPayload(row) {
+        if (!row.credentialSecretId)
+            return {};
+        return parseCredentialPayload(await secrets.resolveSecretValue(row.orgId, row.credentialSecretId, "latest"));
+    }
+    async function buildClientOptions(row) {
+        assertLegacyMutable(row);
+        await validateBoundary({
+            provider: row.provider,
+            transport: row.transport,
+            accessMode: row.accessMode,
+            externalScope: row.externalScope,
+            safeConfig: row.safeConfig,
+        });
+        if (row.transport === "stdio") {
+            const config = asStdioConfig(row.safeConfig);
+            const credential = await resolveCredentialPayload(row);
+            return {
+                transport: "stdio",
+                command: config.command,
+                args: config.args,
+                cwd: config.cwd,
+                staticEnv: config.staticEnv ?? {},
+                forwardedEnv: config.forwardedEnv ?? [],
+                secretEnv: credential.env ?? {},
+                hostEnv,
+                deploymentPolicy: {
+                    deploymentMode: options.deploymentMode,
+                    stdioCommands: allowlists.stdioCommands,
+                    stdioWorkingDirectories: allowlists.stdioWorkingDirectories,
+                    stdioEnvironmentNames: allowlists.stdioEnvironmentNames,
+                },
+                startupTimeoutMs: row.startupTimeoutMs,
+                toolTimeoutMs: row.toolTimeoutMs,
+            };
+        }
+        let url;
+        let curatedOrigin;
+        let credential = {};
+        let oauthCredential;
+        if (row.provider === "custom") {
+            const config = asHttpConfig(row.safeConfig);
+            if (!config.url)
+                throw unprocessable("Custom Streamable HTTP connection requires a URL");
+            url = config.url;
+            credential = await resolveCredentialPayload(row);
+            for (const [headerName, environmentName] of Object.entries(config.headersFromEnv ?? {})) {
+                const value = hostEnv[environmentName];
+                if (value !== undefined) {
+                    credential.headers = { ...(credential.headers ?? {}), [headerName]: value };
+                }
+            }
+            if (config.bearerTokenEnvVar) {
+                credential.bearerToken = hostEnv[config.bearerTokenEnvVar];
+            }
+            assertCustomHttpHeaderPolicy(config, credential);
+        }
+        else {
+            const endpoint = resolveCuratedMcpEndpoint({
+                provider: row.provider,
+                accessMode: row.accessMode,
+                externalScope: row.externalScope,
+            });
+            url = endpoint.href;
+            curatedOrigin = new URL(MCP_PROVIDER_REGISTRY[row.provider].endpoint).origin;
+            const grant = await db
+                .select()
+                .from(mcpOAuthGrants)
+                .where(and(eq(mcpOAuthGrants.orgId, row.orgId), eq(mcpOAuthGrants.connectionId, row.id), eq(mcpOAuthGrants.status, "active")))
+                .then((rows) => rows[0] ?? null);
+            if (!grant?.credentialSecretId) {
+                throw unprocessable("Managed MCP OAuth authorization is required");
+            }
+            if (!options.createOAuthCredential) {
+                throw unprocessable("Managed MCP OAuth credential factory is not configured");
+            }
+            oauthCredential = options.createOAuthCredential(row.orgId, row.id);
+        }
+        const config = asHttpConfig(row.safeConfig);
+        return {
+            transport: "streamable_http",
+            url,
+            staticHeaders: row.provider === "custom" ? config.staticHeaders ?? {} : {},
+            credentials: resolveMcpHttpCredentials({
+                bearerToken: credential.bearerToken,
+                secretHeaders: credential.headers,
+                oauth: oauthCredential,
+            }),
+            network: {
+                allowedOrigins: allowlists.httpOrigins,
+                curatedOrigin,
+                lookup: options.dnsLookup,
+            },
+            startupTimeoutMs: row.startupTimeoutMs,
+            toolTimeoutMs: row.toolTimeoutMs,
+        };
+    }
+    async function listTools(orgId, connectionId) {
+        await findRow(orgId, connectionId);
+        return db
+            .select()
+            .from(customIntegrationTools)
+            .where(and(eq(customIntegrationTools.orgId, orgId), eq(customIntegrationTools.connectionId, connectionId)))
+            .orderBy(asc(customIntegrationTools.externalToolName))
+            .then((rows) => rows.map(publicTool));
+    }
+    return {
+        catalog: () => MCP_PROVIDER_CATALOG.map((entry) => ({
+            ...entry,
+            transports: [...entry.transports],
+            accessModes: [...entry.accessModes],
+        })),
+        list: (orgId) => db
+            .select()
+            .from(mcpConnections)
+            .where(eq(mcpConnections.orgId, orgId))
+            .orderBy(asc(mcpConnections.displayName))
+            .then((rows) => rows.map(publicSummary)),
+        get: async (orgId, connectionId) => publicSummary(await findRow(orgId, connectionId)),
+        openRuntimeClient: async (orgId, connectionId) => {
+            const connection = await findRow(orgId, connectionId);
+            if (connection.status !== "active"
+                || !connection.enabled
+                || connection.transport === "legacy_manual") {
+                throw unprocessable("Managed MCP connection is unavailable");
+            }
+            return createClient(await buildClientOptions(connection));
+        },
+        create: async (orgId, rawInput, actor = {}) => {
+            const input = createMcpConnectionSchema.parse(rawInput);
+            if (input.transport === "legacy_manual") {
+                throw unprocessable("Legacy manual MCP definitions cannot be created as managed connections");
+            }
+            await validateBoundary({
+                provider: input.provider,
+                transport: input.transport,
+                accessMode: input.accessMode,
+                externalScope: input.externalScope ?? null,
+                safeConfig: input.safeConfig,
+                credentials: input.secrets ? customSecretPayload(input.secrets) : undefined,
+            });
+            const credential = input.secrets
+                ? await prepareCredentialReplacement(input.name, input.secrets)
+                : null;
+            try {
+                const row = await db.transaction(async (tx) => {
+                    if (credential) {
+                        await tx.insert(organizationSecrets).values({
+                            id: credential.id,
+                            orgId,
+                            name: credential.name,
+                            provider: "local_encrypted",
+                            purpose: "managed_mcp_connection",
+                            externalRef: credential.externalRef,
+                            latestVersion: 1,
+                            description: "Encrypted managed MCP credentials",
+                            createdByAgentId: actor.agentId ?? null,
+                            createdByUserId: actor.userId ?? null,
+                        });
+                        await tx.insert(organizationSecretVersions).values({
+                            secretId: credential.id,
+                            version: 1,
+                            material: credential.material,
+                            valueSha256: credential.valueSha256,
+                            createdByAgentId: actor.agentId ?? null,
+                            createdByUserId: actor.userId ?? null,
+                        });
+                    }
+                    const created = await tx.insert(mcpConnections).values({
+                        orgId,
+                        credentialSecretId: credential?.id ?? null,
+                        name: input.name,
+                        displayName: input.displayName,
+                        provider: input.provider,
+                        transport: input.transport,
+                        externalScope: input.externalScope ?? null,
+                        accessMode: input.accessMode,
+                        status: "draft",
+                        safeConfig: input.safeConfig,
+                        startupTimeoutMs: input.startupTimeoutMs,
+                        toolTimeoutMs: input.toolTimeoutMs,
+                        enabled: input.enabled,
+                        required: input.required,
+                    })
+                        .returning()
+                        .then((rows) => rows[0]);
+                    await tx.insert(activityLog).values(managedMcpActivityValues({
+                        orgId,
+                        connectionId: created.id,
+                        action: "mcp_connection.created",
+                        actor,
+                        details: {
+                            provider: created.provider,
+                            transport: created.transport,
+                            status: created.status,
+                        },
+                    }));
+                    return created;
+                });
+                return publicSummary(row);
+            }
+            catch (error) {
+                if (error instanceof Error && /unique|duplicate/iu.test(error.message)) {
+                    throw conflict("MCP connection name or provider scope already exists");
+                }
+                throw error;
+            }
+        },
+        update: async (orgId, connectionId, rawPatch, actor = {}, control = {}) => {
+            const existing = await findRow(orgId, connectionId);
+            assertLegacyMutable(existing);
+            const patch = updateMcpConnectionSchema.parse(rawPatch);
+            if (patch.enabled === true
+                && RECONNECT_REQUIRED_STATUSES.has(existing.status)) {
+                throw reconnectRequiredError();
+            }
+            const merged = {
+                provider: existing.provider,
+                transport: existing.transport,
+                accessMode: patch.accessMode ?? existing.accessMode,
+                safeConfig: patch.safeConfig ?? existing.safeConfig,
+                enabled: patch.enabled ?? existing.enabled,
+            };
+            mcpConnectionMergedConfigSchema.parse(merged);
+            if (patch.accessMode !== undefined
+                && existing.provider !== "custom"
+                && !control.allowCuratedAccessMode) {
+                throw unprocessable("Curated MCP access mode must be changed through the dedicated access-mode operation");
+            }
+            if (existing.provider === "linear"
+                && patch.accessMode !== undefined
+                && patch.accessMode !== existing.accessMode
+                && (existing.status === "active" || existing.status === "authorizing")) {
+                throw unprocessable("Linear access-mode changes require reauthorization: disconnect, select the new access mode, then reconnect OAuth");
+            }
+            const previousShape = declaredSecretShape(existing.transport, existing.safeConfig);
+            const nextShape = declaredSecretShape(existing.transport, merged.safeConfig);
+            const declarationChanged = !equalSecretShape(previousShape, nextShape);
+            if (patch.secrets || declarationChanged) {
+                if (hasDeclaredSecrets(nextShape) && !patch.secrets) {
+                    throw unprocessable("Changed managed MCP secret declarations require exact replacement values");
+                }
+                mcpConnectionMutationConfigSchema.parse({
+                    ...merged,
+                    ...(patch.secrets ? { secrets: patch.secrets } : {}),
+                });
+            }
+            await validateBoundary({
+                ...merged,
+                externalScope: patch.externalScope === undefined
+                    ? existing.externalScope
+                    : patch.externalScope ?? null,
+                credentials: patch.secrets ? customSecretPayload(patch.secrets) : undefined,
+            });
+            let credentialSecretId = existing.credentialSecretId;
+            let oldSecretIdToDelete = null;
+            const replacement = patch.secrets
+                ? await prepareCredentialReplacement(existing.name, patch.secrets)
+                : null;
+            if (replacement) {
+                oldSecretIdToDelete = credentialSecretId;
+                credentialSecretId = replacement.id;
+            }
+            else if (declarationChanged && !hasDeclaredSecrets(nextShape) && credentialSecretId) {
+                oldSecretIdToDelete = credentialSecretId;
+                credentialSecretId = null;
+            }
+            const row = await db.transaction(async (tx) => {
+                const locked = await tx
+                    .select()
+                    .from(mcpConnections)
+                    .where(and(eq(mcpConnections.orgId, orgId), eq(mcpConnections.id, connectionId)))
+                    .for("update")
+                    .then((rows) => rows[0] ?? null);
+                if (!locked)
+                    throw notFound("MCP connection not found");
+                if (locked.credentialSecretId !== existing.credentialSecretId) {
+                    throw conflict("Managed MCP credentials changed; retry the connection update");
+                }
+                if (patch.enabled === true
+                    && RECONNECT_REQUIRED_STATUSES.has(locked.status)) {
+                    throw reconnectRequiredError();
+                }
+                if (locked.provider === "linear"
+                    && patch.accessMode !== undefined
+                    && patch.accessMode !== locked.accessMode
+                    && (locked.status === "active" || locked.status === "authorizing")) {
+                    throw unprocessable("Linear access-mode changes require reauthorization: disconnect, select the new access mode, then reconnect OAuth");
+                }
+                if (replacement) {
+                    await tx.insert(organizationSecrets).values({
+                        id: replacement.id,
+                        orgId,
+                        name: replacement.name,
+                        provider: "local_encrypted",
+                        purpose: "managed_mcp_connection",
+                        externalRef: replacement.externalRef,
+                        latestVersion: 1,
+                        description: "Encrypted managed MCP credentials",
+                        createdByAgentId: actor.agentId ?? null,
+                        createdByUserId: actor.userId ?? null,
+                    });
+                    await tx.insert(organizationSecretVersions).values({
+                        secretId: replacement.id,
+                        version: 1,
+                        material: replacement.material,
+                        valueSha256: replacement.valueSha256,
+                        createdByAgentId: actor.agentId ?? null,
+                        createdByUserId: actor.userId ?? null,
+                    });
+                }
+                const updated = await tx
+                    .update(mcpConnections)
+                    .set({
+                    credentialSecretId,
+                    ...(patch.displayName !== undefined ? { displayName: patch.displayName } : {}),
+                    ...(patch.externalScope !== undefined ? { externalScope: patch.externalScope ?? null } : {}),
+                    ...(patch.accessMode !== undefined ? { accessMode: patch.accessMode } : {}),
+                    ...(patch.safeConfig !== undefined ? { safeConfig: patch.safeConfig } : {}),
+                    ...(patch.startupTimeoutMs !== undefined ? { startupTimeoutMs: patch.startupTimeoutMs } : {}),
+                    ...(patch.toolTimeoutMs !== undefined ? { toolTimeoutMs: patch.toolTimeoutMs } : {}),
+                    ...(patch.enabled !== undefined ? {
+                        enabled: patch.enabled,
+                        disabledAt: patch.enabled ? null : new Date(),
+                        status: patch.enabled ? locked.status : "disabled",
+                    } : {}),
+                    ...(patch.required !== undefined ? { required: patch.required } : {}),
+                    lifecycleRevision: locked.lifecycleRevision + 1,
+                    updatedAt: nextConnectionMutationTime(locked),
+                })
+                    .where(and(eq(mcpConnections.orgId, orgId), eq(mcpConnections.id, connectionId)))
+                    .returning()
+                    .then((rows) => rows[0] ?? null);
+                if (!updated)
+                    throw notFound("MCP connection not found");
+                if (oldSecretIdToDelete) {
+                    await tx
+                        .delete(organizationSecrets)
+                        .where(eq(organizationSecrets.id, oldSecretIdToDelete));
+                }
+                await tx.insert(activityLog).values(managedMcpActivityValues({
+                    orgId,
+                    connectionId,
+                    action: "mcp_connection.updated",
+                    actor,
+                    details: {
+                        provider: updated.provider,
+                        status: updated.status,
+                        accessMode: updated.accessMode,
+                    },
+                }));
+                return updated;
+            });
+            return publicSummary(row);
+        },
+        reconnect: async (orgId, connectionId, actor = {}) => {
+            const existing = await findRow(orgId, connectionId);
+            assertLegacyMutable(existing);
+            const now = nextConnectionMutationTime(existing);
+            const row = await db.transaction(async (tx) => {
+                const updated = await tx
+                    .update(mcpConnections)
+                    .set({
+                    status: existing.provider === "custom" ? "draft" : "authorizing",
+                    enabled: true,
+                    disabledAt: null,
+                    revokedAt: null,
+                    lifecycleRevision: sql `${mcpConnections.lifecycleRevision} + 1`,
+                    updatedAt: now,
+                })
+                    .where(and(eq(mcpConnections.orgId, orgId), eq(mcpConnections.id, connectionId)))
+                    .returning()
+                    .then((rows) => rows[0] ?? null);
+                if (!updated)
+                    throw notFound("MCP connection not found");
+                if (existing.provider !== "custom") {
+                    const activeGrant = await tx.select().from(mcpOAuthGrants)
+                        .where(and(eq(mcpOAuthGrants.orgId, orgId), eq(mcpOAuthGrants.connectionId, connectionId), eq(mcpOAuthGrants.status, "active")))
+                        .for("update")
+                        .then((rows) => rows[0] ?? null);
+                    if (activeGrant) {
+                        await tx.update(mcpOAuthGrants).set({
+                            status: "needs_reauth",
+                            statusMetadata: { reason: "connection_reconnect" },
+                            credentialSecretId: null,
+                            refreshLeaseNonce: null,
+                            refreshLeaseExpiresAt: null,
+                            updatedAt: now,
+                        }).where(eq(mcpOAuthGrants.id, activeGrant.id));
+                        if (activeGrant.credentialSecretId) {
+                            await tx.delete(organizationSecrets)
+                                .where(eq(organizationSecrets.id, activeGrant.credentialSecretId));
+                        }
+                    }
+                }
+                await tx.insert(activityLog).values(managedMcpActivityValues({
+                    orgId,
+                    connectionId,
+                    action: "mcp_connection.reconnect_requested",
+                    actor,
+                    details: {
+                        provider: updated.provider,
+                        status: updated.status,
+                    },
+                }));
+                return updated;
+            });
+            return publicSummary(row);
+        },
+        disconnect: async (orgId, connectionId, actor = {}) => {
+            const existing = await findRow(orgId, connectionId);
+            assertLegacyMutable(existing);
+            const now = nextConnectionMutationTime(existing);
+            const row = await db.transaction(async (tx) => {
+                const updated = await tx
+                    .update(mcpConnections)
+                    .set({
+                    status: "disabled",
+                    enabled: false,
+                    disabledAt: now,
+                    lifecycleRevision: sql `${mcpConnections.lifecycleRevision} + 1`,
+                    updatedAt: now,
+                })
+                    .where(and(eq(mcpConnections.orgId, orgId), eq(mcpConnections.id, connectionId)))
+                    .returning()
+                    .then((rows) => rows[0] ?? null);
+                if (!updated)
+                    throw notFound("MCP connection not found");
+                await tx.insert(activityLog).values(managedMcpActivityValues({
+                    orgId,
+                    connectionId,
+                    action: "mcp_connection.disconnected",
+                    actor,
+                    details: {
+                        provider: updated.provider,
+                        status: updated.status,
+                    },
+                }));
+                return updated;
+            });
+            return publicSummary(row);
+        },
+        listTools,
+        refreshTools: async (orgId, connectionId, actor = {}) => {
+            const existing = await findRow(orgId, connectionId);
+            assertLegacyMutable(existing);
+            if (existing.provider === "supabase" && !existing.externalScope) {
+                throw unprocessable("Supabase MCP connections require a selected project before discovery");
+            }
+            if (!canDiscoverTools(existing)) {
+                throw discoveryNotReadyError();
+            }
+            const snapshot = discoverySnapshot(existing);
+            let client = null;
+            try {
+                client = await createClient(await buildClientOptions(existing));
+                const normalized = normalizeMcpDiscoveredTools(existing.name, await client.discoverTools(), discoveryFilter(existing));
+                const normalizedByName = new Map(normalized.map((tool) => [tool.externalToolName, tool]));
+                await db.transaction(async (tx) => {
+                    const locked = await tx
+                        .select()
+                        .from(mcpConnections)
+                        .where(and(eq(mcpConnections.orgId, orgId), eq(mcpConnections.id, connectionId)))
+                        .for("update")
+                        .then((rows) => rows[0] ?? null);
+                    if (!locked)
+                        throw notFound("MCP connection not found");
+                    assertDiscoverySnapshot(locked, snapshot);
+                    const now = nextConnectionMutationTime(locked);
+                    const existingTools = await tx
+                        .select()
+                        .from(customIntegrationTools)
+                        .where(and(eq(customIntegrationTools.orgId, orgId), eq(customIntegrationTools.connectionId, connectionId)));
+                    const reconciled = reconcileMcpToolCatalog(existingTools, normalized);
+                    const existingByName = new Map(existingTools.map((tool) => [tool.externalToolName, tool]));
+                    for (const tool of reconciled) {
+                        const prior = existingByName.get(tool.externalToolName);
+                        const current = normalizedByName.get(tool.externalToolName);
+                        if (prior) {
+                            await tx
+                                .update(customIntegrationTools)
+                                .set({
+                                ...(current ? {
+                                    rudderToolName: current.rudderToolName,
+                                    description: current.description,
+                                    rawInputSchema: current.rawInputSchema,
+                                    inputSchema: current.inputSchema,
+                                    rawOutputSchema: current.rawOutputSchema,
+                                    outputSchema: current.outputSchema,
+                                    discoveredAt: now,
+                                } : {}),
+                                status: tool.status,
+                                enabled: tool.enabled,
+                                removedAt: tool.status === "removed" ? now : null,
+                                updatedAt: now,
+                            })
+                                .where(eq(customIntegrationTools.id, prior.id));
+                        }
+                        else if (current) {
+                            await tx.insert(customIntegrationTools).values({
+                                orgId,
+                                connectionId,
+                                externalToolName: current.externalToolName,
+                                rudderToolName: current.rudderToolName,
+                                description: current.description,
+                                rawInputSchema: current.rawInputSchema,
+                                inputSchema: current.inputSchema,
+                                rawOutputSchema: current.rawOutputSchema,
+                                outputSchema: current.outputSchema,
+                                status: "active",
+                                enabled: true,
+                                discoveredAt: now,
+                            });
+                        }
+                    }
+                    await tx
+                        .update(mcpConnections)
+                        .set({
+                        status: "active",
+                        enabled: true,
+                        activatedAt: locked.activatedAt ?? now,
+                        lastDiscoveredAt: now,
+                        disabledAt: null,
+                        lifecycleRevision: locked.lifecycleRevision + 1,
+                        updatedAt: now,
+                    })
+                        .where(and(eq(mcpConnections.orgId, orgId), eq(mcpConnections.id, connectionId)));
+                    await tx.insert(activityLog).values(managedMcpActivityValues({
+                        orgId,
+                        connectionId,
+                        action: "mcp_connection.tools_refreshed",
+                        actor,
+                        details: {
+                            provider: locked.provider,
+                            toolCount: normalized.length,
+                        },
+                    }));
+                });
+                return listTools(orgId, connectionId);
+            }
+            catch (error) {
+                if (error instanceof ManagedMcpDiscoveryStaleError) {
+                    throw error;
+                }
+                await db.transaction(async (tx) => {
+                    const locked = await tx
+                        .select()
+                        .from(mcpConnections)
+                        .where(and(eq(mcpConnections.orgId, orgId), eq(mcpConnections.id, connectionId)))
+                        .for("update")
+                        .then((rows) => rows[0] ?? null);
+                    if (!locked)
+                        throw notFound("MCP connection not found");
+                    assertDiscoverySnapshot(locked, snapshot);
+                    const now = nextConnectionMutationTime(locked);
+                    await tx
+                        .update(mcpConnections)
+                        .set({
+                        status: "error",
+                        lifecycleRevision: locked.lifecycleRevision + 1,
+                        updatedAt: now,
+                    })
+                        .where(and(eq(mcpConnections.orgId, orgId), eq(mcpConnections.id, connectionId)));
+                    await tx.insert(activityLog).values(managedMcpActivityValues({
+                        orgId,
+                        connectionId,
+                        action: "mcp_connection.discovery_failed",
+                        actor,
+                        details: {
+                            provider: locked.provider,
+                            reason: "upstream_discovery_failed",
+                        },
+                    }));
+                });
+                if (error instanceof HttpError) {
+                    throw error;
+                }
+                throw redactedDiscoveryError();
+            }
+            finally {
+                await client?.close().catch(() => undefined);
+            }
+        },
+    };
+}
+//# sourceMappingURL=managed-connections.js.map