devpush 0.0.0-stage → 1.0.0-beta.3

package/src/server/mcp/handler.ts

@@ -0,0 +1,295 @@
+import { createMcpHandler, McpServer } from '@modelcontextprotocol/server'
+import { z } from 'zod'
+import { isAPIError as isAuthApiError } from 'better-auth/api'
+import { safeErrorDiagnostics } from '#devpush/server/http/error-diagnostics'
+import { auth } from '#devpush/server/auth/better-auth'
+import { PublicError, getPublicErrorMessage } from '#devpush/lib/public-error'
+import { authenticateApiKey } from '#devpush/server/api/credentials'
+import type { ApiPrincipal } from '#devpush/server/api/authorization'
+import { requireApiScope } from '#devpush/server/api/authorization'
+import { ApiError } from '#devpush/server/api/errors'
+import { executeApiOperation } from '#devpush/server/api/operations'
+import { publicApiOperations } from '#devpush/server/api/operation-contract'
+import { config } from '#devpush/server/config'
+import { enforceRateLimit } from '#devpush/server/http/rate-limit'
+import { mcpOAuthScopes, mcpResource } from './oauth-provider'
+import { createMcpUrls } from './urls'
+
+const { origins, metadata } = createMcpUrls(config)
+const mcpResourceMetadataUrl = metadata
+
+export function getMcpResourceMetadata() {
+  return Response.json(
+    {
+      resource: mcpResource,
+      resource_name: 'devpush MCP',
+      authorization_servers: [
+        new URL('/api/auth', config.BETTER_AUTH_URL).toString(),
+      ],
+      bearer_methods_supported: ['header'],
+      scopes_supported: [...mcpOAuthScopes],
+    },
+    { headers: { 'cache-control': 'public, max-age=300' } },
+  )
+}
+
+export async function authenticateMcpRequest(
+  request: Request,
+): Promise<ApiPrincipal> {
+  const authorization = request.headers.get('authorization') ?? ''
+  if (/^Bearer dp_/i.test(authorization)) return authenticateApiKey(request)
+  const token = authorization.match(/^Bearer ([^\s]+)$/i)?.[1]
+  if (!token) throw new PublicError('UNAUTHORIZED')
+  // Provider-owned verification checks cryptographic validity, audience, active
+  // session/client/token family, and our current stored consent and grant.
+  return auth.api.verifyMcpAccessToken({ body: { token } })
+}
+
+function createDevpushMcpHandler(principal: ApiPrincipal, requestId: string) {
+  return createMcpHandler(
+    () => {
+      const server = new McpServer(
+        { name: 'devpush', version: '1.0.0' },
+        { maxToolInputElements: 4096 },
+      )
+      for (const operation of publicApiOperations.filter((entry) => {
+        if (
+          !entry.mcp ||
+          (entry.requiresWholeTeam && principal.projectIds !== null)
+        )
+          return false
+        try {
+          requireApiScope(principal, entry.scope, entry.minimumRole)
+          return true
+        } catch {
+          return false
+        }
+      })) {
+        const addConfirmation =
+          operation.destructive && !('confirmation' in operation.input.shape)
+        const inputSchema = addConfirmation
+          ? operation.input.extend({ confirmation: z.literal(operation.id) })
+          : operation.input
+        server.registerTool(
+          operation.id,
+          {
+            description: operation.description,
+            inputSchema,
+            outputSchema: operation.output,
+            annotations: {
+              readOnlyHint: operation.readOnly,
+              destructiveHint: operation.destructive,
+              idempotentHint:
+                operation.readOnly || 'idempotencyKey' in operation.input.shape,
+              openWorldHint: !operation.readOnly,
+            },
+          },
+          async (args) => {
+            const input = { ...args }
+            if (addConfirmation) delete input.confirmation
+            try {
+              const result = await executeApiOperation({
+                operationId: operation.id,
+                input,
+                principal,
+                requestId,
+              })
+              const output = result.data as Record<string, unknown>
+              return {
+                content: [
+                  { type: 'text' as const, text: JSON.stringify(output) },
+                ],
+                structuredContent: output,
+              }
+            } catch (error) {
+              const code =
+                error instanceof ApiError || error instanceof PublicError
+                  ? error.code
+                  : error instanceof z.ZodError
+                    ? 'INVALID_INPUT'
+                    : 'INTERNAL_ERROR'
+              const message =
+                error instanceof ApiError
+                  ? error.message
+                  : getPublicErrorMessage(
+                      error,
+                      'Unable to complete this operation.',
+                    )
+              if (code === 'INTERNAL_ERROR')
+                console.error('MCP operation failed', {
+                  requestId,
+                  operation: operation.id,
+                })
+              return {
+                isError: true,
+                content: [
+                  {
+                    type: 'text' as const,
+                    text: JSON.stringify({
+                      error: { code, message, requestId },
+                    }),
+                  },
+                ],
+              }
+            }
+          },
+        )
+      }
+      return server
+    },
+    {
+      legacy: 'stateless',
+      responseMode: 'auto',
+      maxRequestBodySize: 128 * 1024,
+      maxSubscriptions: 0,
+    },
+  )
+}
+
+export async function handleMcpRequest(request: Request) {
+  const origin = request.headers.get('origin')
+  if (origin && !origins.has(origin))
+    return Response.json({ error: 'Origin is not allowed.' }, { status: 403 })
+  if (!origins.has(new URL(request.url).origin))
+    return Response.json({ error: 'Host is not allowed.' }, { status: 403 })
+  const cors: Record<string, string> = origin
+    ? {
+        'access-control-allow-origin': origin,
+        'access-control-allow-methods': 'POST, GET, DELETE, OPTIONS',
+        'access-control-allow-headers':
+          'Authorization, Content-Type, MCP-Protocol-Version, MCP-Session-Id, MCP-Method, MCP-Name',
+        'access-control-expose-headers':
+          'WWW-Authenticate, MCP-Protocol-Version',
+        vary: 'Origin',
+      }
+    : {}
+  if (request.method === 'OPTIONS')
+    return new Response(null, { status: 204, headers: cors })
+  const requestId = crypto.randomUUID()
+  function withResponseHeaders(response: Response) {
+    const headers = new Headers(response.headers)
+    for (const [name, value] of Object.entries(cors)) {
+      if (name === 'vary') headers.append(name, value)
+      else headers.set(name, value)
+    }
+    headers.set(
+      'cache-control',
+      response.headers.get('content-type')?.startsWith('text/event-stream')
+        ? 'no-store, no-transform'
+        : 'no-store',
+    )
+    headers.set('x-request-id', requestId)
+    return new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers,
+    })
+  }
+  const transportLimited = await enforceRateLimit({
+    request,
+    scope: 'mcp-transport',
+    limit: 180,
+    windowMs: 60_000,
+  })
+  if (transportLimited) return withResponseHeaders(transportLimited)
+  let principal: ApiPrincipal
+  try {
+    principal = await authenticateMcpRequest(request)
+  } catch (error) {
+    const invalidCredentials =
+      (error instanceof PublicError &&
+        ['UNAUTHORIZED', 'FORBIDDEN'].includes(error.code)) ||
+      (isAuthApiError(error) &&
+        error.statusCode >= 400 &&
+        error.statusCode < 500)
+    if (!invalidCredentials) {
+      console.error('MCP authentication failed', {
+        requestId,
+        ...safeErrorDiagnostics(error),
+      })
+      return withResponseHeaders(
+        Response.json(
+          {
+            error: {
+              code: 'INTERNAL_ERROR',
+              message: 'Unable to authenticate this request. Try again.',
+              requestId,
+            },
+          },
+          { status: 500 },
+        ),
+      )
+    }
+    return Response.json(
+      {
+        error: {
+          code: 'UNAUTHORIZED',
+          message:
+            'Provide a valid API key or connect through browser authorization.',
+          requestId,
+        },
+      },
+      {
+        status: 401,
+        headers: {
+          ...cors,
+          'www-authenticate': `Bearer resource_metadata="${mcpResourceMetadataUrl}"`,
+          'cache-control': 'no-store',
+          'x-request-id': requestId,
+        },
+      },
+    )
+  }
+  const limited = await enforceRateLimit({
+    request,
+    scope: `mcp:${principal.credentialId}`,
+    limit: 120,
+    windowMs: 60_000,
+  })
+  if (limited) return withResponseHeaders(limited)
+  const handler = createDevpushMcpHandler(principal, requestId)
+  let closing: Promise<void> | undefined
+  const close = () => (closing ??= handler.close())
+  try {
+    const response = await handler.fetch(request)
+    if (
+      response.body &&
+      response.headers.get('content-type')?.startsWith('text/event-stream')
+    ) {
+      const reader = response.body.getReader()
+      const body = new ReadableStream<Uint8Array>({
+        async pull(controller) {
+          try {
+            const chunk = await reader.read()
+            if (chunk.done) {
+              controller.close()
+              await close()
+            } else controller.enqueue(chunk.value)
+          } catch (error) {
+            controller.error(error)
+            await close()
+          }
+        },
+        async cancel(reason) {
+          try {
+            await reader.cancel(reason)
+          } finally {
+            await close()
+          }
+        },
+      })
+      return withResponseHeaders(
+        new Response(body, {
+          status: response.status,
+          statusText: response.statusText,
+          headers: response.headers,
+        }),
+      )
+    }
+    await close()
+    return withResponseHeaders(response)
+  } catch (error) {
+    await close()
+    throw error
+  }
+}

package/src/server/mcp/oauth-discovery.cloudflare.ts

@@ -0,0 +1,6 @@
+// Workers does not implement dns.lookup / a pinned HTTPS lookup boundary.
+// Keep OAuth dynamic registration available; do not advertise unsupported CIMD
+// or fall back to fetch(), which cannot prevent DNS rebinding here.
+export function oauthDiscoveryPlugins() {
+  return []
+}

package/src/server/mcp/oauth-discovery.ts

@@ -0,0 +1,8 @@
+import { cimd } from '@better-auth/cimd'
+import { fetchClientMetadataResource } from '@better-auth/cimd/node'
+
+export function oauthDiscoveryPlugins() {
+  return [
+    cimd({ fetchClientMetadataResource, metadataProfile: 'mcp-2026-07-28' }),
+  ] as const
+}

package/src/server/mcp/oauth-provider.ts

@@ -0,0 +1,220 @@
+import { getCurrentAuthEndpointContext } from '@better-auth/core/context'
+import { getOAuthProviderApi, oauthProvider } from '@better-auth/oauth-provider'
+import {
+  APIError,
+  createAuthEndpoint,
+  createAuthMiddleware,
+} from 'better-auth/api'
+import { and, eq } from 'drizzle-orm'
+import { z } from 'zod'
+import type { BetterAuthPlugin } from 'better-auth'
+import {
+  apiKeyPresetSchema,
+  scopesForApiPreset,
+} from '#devpush/lib/api-key-schema'
+
+import { config } from '#devpush/server/config'
+import { db } from '#devpush/server/db'
+import { apiGrants, oauthConsent } from '#devpush/server/db/schema'
+import { resolveApiGrant } from '#devpush/server/api/credentials'
+import { oauthDiscoveryPlugins } from '#devpush/server/mcp/oauth-discovery'
+
+export const mcpResource = config.DEVPUSH_MCP_URL
+export const mcpOAuthScopes = [
+  'devpush:read',
+  'devpush:deploy',
+  'devpush:manage',
+  'devpush:logs',
+  'offline_access',
+] as const
+
+const options = {
+  loginPage: '/auth/login',
+  consentPage: '/oauth/consent',
+  scopes: [...mcpOAuthScopes],
+  resources: [
+    {
+      identifier: mcpResource,
+      name: 'devpush MCP',
+      accessTokenTtl: 600,
+      allowedScopes: [...mcpOAuthScopes],
+    },
+  ],
+  clientRegistrationDefaultResources: [mcpResource],
+  grantTypes: ['authorization_code', 'refresh_token'] as [
+    'authorization_code',
+    'refresh_token',
+  ],
+  allowDynamicClientRegistration: true,
+  allowUnauthenticatedClientRegistration: true,
+  clientRegistrationDefaultApplicationType: 'infer' as const,
+  clientRegistrationRequirePKCE: true,
+  // Provider-owned opaque tokens allow immediate token-family revocation.
+  // Locally verified JWTs remain valid after refresh-token replay otherwise.
+  disableJwtPlugin: true,
+  clientPrivileges: async () => false,
+  accessTokenExpiresIn: 600,
+  refreshTokenExpiresIn: 30 * 24 * 60 * 60,
+  postLogin: {
+    page: '/oauth/consent',
+    shouldRedirect: async () => false,
+    consentReferenceId: async ({ user }: { user: { id: string } }) => {
+      const ctx = getCurrentAuthEndpointContext()
+      const grantId = ctx.headers?.get('x-devpush-mcp-grant')
+      if (!grantId) return undefined
+      const principal = await resolveApiGrant(grantId)
+      const query = new URLSearchParams(ctx.body?.oauth_query ?? '')
+      const clientId = query.get('client_id')
+      const [grant] = await db
+        .select()
+        .from(apiGrants)
+        .where(eq(apiGrants.id, grantId))
+        .limit(1)
+      if (
+        principal.userId !== user.id ||
+        !clientId ||
+        grant?.providerGrantId !== clientId
+      )
+        throw new APIError('FORBIDDEN', {
+          message: 'Invalid MCP authorization.',
+        })
+      return grantId
+    },
+  },
+  customAccessTokenClaims: async ({
+    user,
+    referenceId,
+    resources,
+  }: {
+    user?: { id: string } | null
+    referenceId?: string
+    resources?: string[]
+  }) => {
+    if (
+      !user ||
+      !referenceId ||
+      resources?.length !== 1 ||
+      resources[0] !== mcpResource
+    )
+      throw new APIError('FORBIDDEN', {
+        message: 'MCP authorization is required.',
+      })
+    const principal = await resolveApiGrant(referenceId)
+    if (principal.userId !== user.id)
+      throw new APIError('FORBIDDEN', { message: 'Invalid MCP authorization.' })
+    return { devpush_grant_id: referenceId }
+  },
+}
+
+function mcpOAuthBridge() {
+  return {
+    id: 'devpush-mcp-authorization',
+    hooks: {
+      before: [
+        {
+          matcher: (ctx) => ctx.path === '/oauth2/authorize',
+          handler: createAuthMiddleware(async (ctx) => {
+            // Every browser connection chooses its own resource grant. A previous
+            // client's consent must not silently select an unrelated team.
+            if (!ctx.headers?.has('x-devpush-mcp-grant')) {
+              const prompt = new Set(
+                String(ctx.query?.prompt ?? '')
+                  .split(' ')
+                  .filter(Boolean),
+              )
+              prompt.add('consent')
+              return {
+                context: {
+                  query: { ...ctx.query, prompt: [...prompt].join(' ') },
+                },
+              }
+            }
+          }),
+        },
+      ],
+    },
+    endpoints: {
+      verifyMcpAccessToken: createAuthEndpoint(
+        '/mcp/verify',
+        {
+          method: 'POST',
+          body: z.object({ token: z.string().min(1).max(8192) }),
+        },
+        async (ctx) => {
+          const claims = await getOAuthProviderApi(
+            ctx,
+            options,
+          ).requireActiveAccessToken(ctx.body.token)
+          const audience =
+            typeof claims.aud === 'string' ? [claims.aud] : claims.aud
+          if (
+            !audience?.includes(mcpResource) ||
+            typeof claims.devpush_grant_id !== 'string' ||
+            typeof claims.sub !== 'string'
+          )
+            throw new APIError('UNAUTHORIZED', {
+              message: 'Invalid MCP access token.',
+            })
+          const principal = await resolveApiGrant(claims.devpush_grant_id)
+          const [grant] = await db
+            .select()
+            .from(apiGrants)
+            .where(eq(apiGrants.id, principal.credentialId))
+            .limit(1)
+          const clientId = claims.client_id ?? claims.azp
+          const [consent] = await db
+            .select({ id: oauthConsent.id })
+            .from(oauthConsent)
+            .where(
+              and(
+                eq(oauthConsent.referenceId, principal.credentialId),
+                eq(oauthConsent.userId, principal.userId),
+                eq(oauthConsent.clientId, String(clientId)),
+              ),
+            )
+            .limit(1)
+          if (
+            claims.sub !== principal.userId ||
+            grant?.providerGrantId !== clientId ||
+            !consent
+          )
+            throw new APIError('UNAUTHORIZED', {
+              message: 'This MCP connection is no longer authorized.',
+            })
+          const tokenScopes = new Set(
+            typeof claims.scope === 'string' ? claims.scope.split(' ') : [],
+          )
+          const permittedScopes = new Set<string>(
+            apiKeyPresetSchema.options.flatMap((preset) =>
+              tokenScopes.has(`devpush:${preset}`)
+                ? scopesForApiPreset(
+                    preset,
+                    principal.roleCeiling,
+                    tokenScopes.has('devpush:logs'),
+                  )
+                : [],
+            ),
+          )
+          if (permittedScopes.size === 0)
+            throw new APIError('UNAUTHORIZED', {
+              message: 'MCP access permissions are required.',
+            })
+          return {
+            ...principal,
+            scopes: principal.scopes.filter((scope) =>
+              permittedScopes.has(scope),
+            ),
+          }
+        },
+      ),
+    },
+  } satisfies BetterAuthPlugin
+}
+
+export function mcpOAuthPlugins() {
+  return [
+    oauthProvider(options),
+    ...oauthDiscoveryPlugins(),
+    mcpOAuthBridge(),
+  ] as const
+}

package/src/server/mcp/urls.ts

@@ -0,0 +1,20 @@
+export function createMcpUrls(config: {
+  DEVPUSH_MCP_URL: string
+  DEVPUSH_BASE_URL: string
+  BETTER_AUTH_URL: string
+}) {
+  return {
+    resource: config.DEVPUSH_MCP_URL,
+    metadata: new URL(
+      '/.well-known/oauth-protected-resource/mcp',
+      config.DEVPUSH_MCP_URL,
+    ).toString(),
+    origins: new Set(
+      [
+        config.DEVPUSH_MCP_URL,
+        config.DEVPUSH_BASE_URL,
+        config.BETTER_AUTH_URL,
+      ].map((url) => new URL(url).origin),
+    ),
+  }
+}

package/src/server/notifications/functions.ts

@@ -0,0 +1,51 @@
+import { createServerFn } from '@tanstack/react-start'
+import { z } from 'zod'
+import { requireAuthSession } from '#devpush/server/auth/session.server'
+import { publicErrorsMiddleware } from '#devpush/server/http/public-errors'
+import {
+  notificationPreferencesSchema,
+  notificationScopeSchema,
+} from '#devpush/lib/notification-preferences'
+import {
+  readNotificationPreferences,
+  saveNotificationPreferences,
+  readNotificationMute,
+  saveNotificationMute,
+} from './preferences'
+
+export const getNotificationPreferences = createServerFn({ method: 'GET' })
+  .middleware([publicErrorsMiddleware])
+  .handler(async () => {
+    const session = await requireAuthSession()
+    return readNotificationPreferences(session.user.id)
+  })
+export const updateNotificationPreferences = createServerFn({ method: 'POST' })
+  .middleware([publicErrorsMiddleware])
+  .validator(
+    z.object({
+      preferences: notificationPreferencesSchema,
+      version: z.number().int().nonnegative(),
+    }),
+  )
+  .handler(async ({ data }) => {
+    const session = await requireAuthSession()
+    return saveNotificationPreferences(
+      session.user.id,
+      data.preferences,
+      data.version,
+    )
+  })
+export const getNotificationMute = createServerFn({ method: 'GET' })
+  .middleware([publicErrorsMiddleware])
+  .validator(notificationScopeSchema)
+  .handler(async ({ data }) => {
+    const session = await requireAuthSession()
+    return readNotificationMute(session.user.id, data)
+  })
+export const updateNotificationMute = createServerFn({ method: 'POST' })
+  .middleware([publicErrorsMiddleware])
+  .validator(z.object({ scope: notificationScopeSchema, muted: z.boolean() }))
+  .handler(async ({ data }) => {
+    const session = await requireAuthSession()
+    return saveNotificationMute(session.user.id, data.scope, data.muted)
+  })