Mship byok

Author: Sg312

apps/sim/app/api/admin/mothership/route.ts

@@ -172,3 +172,59 @@ export const GET = withRouteHandler(async (req: NextRequest) => {
     )
   }
 })
+
+export const DELETE = withRouteHandler(async (req: NextRequest) => {
+  const userId = await getAuthorizedAdminUserId()
+  if (!userId) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const adminKey = env.MOTHERSHIP_API_ADMIN_KEY
+  if (!adminKey) {
+    return NextResponse.json({ error: 'MOTHERSHIP_API_ADMIN_KEY not configured' }, { status: 500 })
+  }
+
+  const { searchParams } = new URL(req.url)
+  const queryValidation = adminMothershipQuerySchema.safeParse(searchParamsToObject(searchParams))
+  if (!queryValidation.success) return validationErrorResponse(queryValidation.error)
+  const { env: environment, endpoint } = queryValidation.data
+
+  if (!isValidEndpoint(endpoint)) {
+    return NextResponse.json({ error: 'invalid endpoint' }, { status: 400 })
+  }
+
+  const baseUrl = await getMothershipUrl(environment, userId)
+  if (!baseUrl) {
+    return NextResponse.json(
+      { error: `No URL configured for environment: ${environment}` },
+      { status: 400 }
+    )
+  }
+
+  const forwardParams = new URLSearchParams()
+  searchParams.forEach((value, key) => {
+    if (key !== 'env' && key !== 'endpoint') {
+      forwardParams.set(key, value)
+    }
+  })
+
+  const qs = forwardParams.toString()
+  const targetUrl = `${baseUrl}/api/admin/${endpoint}${qs ? `?${qs}` : ''}`
+
+  try {
+    const upstream = await fetch(targetUrl, {
+      method: 'DELETE',
+      headers: { 'x-api-key': adminKey },
+    })
+
+    const data = await upstream.json()
+    return NextResponse.json(data, { status: upstream.status })
+  } catch (error) {
+    return NextResponse.json(
+      {
+        error: `Failed to reach mothership (${environment}): ${getErrorMessage(error, 'Unknown error')}`,
+      },
+      { status: 502 }
+    )
+  }
+})

apps/sim/app/api/copilot/auto-allowed-tools/route.ts

@@ -0,0 +1,81 @@
+import { db } from '@sim/db'
+import { settings, user } from '@sim/db/schema'
+import { getErrorMessage } from '@sim/utils/errors'
+import { eq } from 'drizzle-orm'
+import { type NextRequest, NextResponse } from 'next/server'
+import { getSession } from '@/lib/auth'
+import { SIM_AGENT_API_URL } from '@/lib/copilot/constants'
+import { getMothershipSourceEnvHeaders } from '@/lib/copilot/server/agent-url'
+import { env } from '@/lib/core/config/env'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+
+/**
+ * Enterprise BYOK key management for the current workspace's mothership.
+ *
+ * Unlike the cross-environment admin inspector (`/api/admin/mothership`), this
+ * talks to the SAME copilot the workspace's mothership actually runs on —
+ * `SIM_AGENT_API_URL` (local in dev, prod copilot in prod) — and authenticates
+ * with the hosted internal key (`COPILOT_API_KEY`), the exact credential
+ * mothership chat uses. Copilot requires that key (`SIM_AGENT_API_KEY`) and
+ * rejects self-hosted callers, so BYOK can only ever be written through our
+ * hosted Sim. The route is superuser-gated; the workspace id rides in the
+ * request and is resolved by the caller from the route.
+ */
+async function getAuthorizedSuperUserId(): Promise<string | null> {
+  const session = await getSession()
+  if (!session?.user?.id) return null
+
+  const [currentUser] = await db
+    .select({ role: user.role, superUserModeEnabled: settings.superUserModeEnabled })
+    .from(user)
+    .leftJoin(settings, eq(settings.userId, user.id))
+    .where(eq(user.id, session.user.id))
+    .limit(1)
+
+  const authorized = currentUser?.role === 'admin' && (currentUser.superUserModeEnabled ?? false)
+  return authorized ? session.user.id : null
+}
+
+async function proxyToCopilot(req: NextRequest, method: 'GET' | 'POST' | 'DELETE') {
+  const userId = await getAuthorizedSuperUserId()
+  if (!userId) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const headers: Record<string, string> = { ...getMothershipSourceEnvHeaders() }
+  if (env.COPILOT_API_KEY) headers['x-api-key'] = env.COPILOT_API_KEY
+
+  let body: string | undefined
+  if (method === 'POST') {
+    const raw = await req.text()
+    // Bind the audit field to the authenticated superuser, ignoring any
+    // client-supplied createdBy so provisioning is always attributable.
+    try {
+      const parsed = raw ? JSON.parse(raw) : {}
+      body = JSON.stringify({ ...parsed, createdBy: userId })
+    } catch {
+      body = raw
+    }
+    headers['Content-Type'] = 'application/json'
+  }
+
+  const { search } = new URL(req.url)
+  const targetUrl = `${SIM_AGENT_API_URL}/api/admin/byok${search}`
+
+  try {
+    const upstream = await fetch(targetUrl, { method, headers, ...(body ? { body } : {}) })
+    const text = await upstream.text()
+    // boundary-raw-fetch: copilot returns JSON; tolerate an empty body.
+    const data = text ? JSON.parse(text) : {}
+    return NextResponse.json(data, { status: upstream.status })
+  } catch (error) {
+    return NextResponse.json(
+      { error: `Failed to reach copilot: ${getErrorMessage(error, 'Unknown error')}` },
+      { status: 502 }
+    )
+  }
+}
+
+export const GET = withRouteHandler((req: NextRequest) => proxyToCopilot(req, 'GET'))
+export const POST = withRouteHandler((req: NextRequest) => proxyToCopilot(req, 'POST'))
+export const DELETE = withRouteHandler((req: NextRequest) => proxyToCopilot(req, 'DELETE'))

apps/sim/app/api/copilot/byok/route.ts

@@ -0,0 +1,74 @@
+import { createLogger } from '@sim/logger'
+import { type NextRequest, NextResponse } from 'next/server'
+import { isWorkspaceOnEnterprisePlan } from '@/lib/billing/core/subscription'
+import { checkInternalApiKey } from '@/lib/copilot/request/http'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import { verifyEffectiveSuperUser } from '@/lib/templates/permissions'
+import { getUserEntityPermissions } from '@/lib/workspaces/permissions/utils'
+
+const logger = createLogger('CopilotByokValidate')
+
+/**
+ * Authoritative entitlement gate for enterprise BYOK, called server-to-server by
+ * the mothership (Go) before it uses a workspace's own provider key. Gated by
+ * INTERNAL_API_SECRET — never exposed to the browser.
+ *
+ * Returns 200 when EITHER:
+ *   - the requesting user is a superuser admin (platform admin with superuser
+ *     mode on), who may use BYOK on any workspace for management/testing; OR
+ *   - the user is a member of the workspace (prevents one org from causing
+ *     another org's stored key to be used) AND the workspace is on an
+ *     enterprise plan.
+ *
+ * Any other case returns 403 (not entitled) or 401 (bad internal auth). The Go
+ * caller fails closed to hosted keys on anything but a 200.
+ */
+export const POST = withRouteHandler(async (req: NextRequest) => {
+  const auth = checkInternalApiKey(req)
+  if (!auth.success) {
+    return new NextResponse(null, { status: 401 })
+  }
+
+  let body: { workspaceId?: unknown; userId?: unknown }
+  try {
+    body = await req.json()
+  } catch {
+    return NextResponse.json({ error: 'Invalid JSON' }, { status: 400 })
+  }
+
+  const workspaceId = typeof body.workspaceId === 'string' ? body.workspaceId : ''
+  const userId = typeof body.userId === 'string' ? body.userId : ''
+  if (!workspaceId || !userId) {
+    return NextResponse.json({ error: 'workspaceId and userId are required' }, { status: 400 })
+  }
+
+  try {
+    // Superuser admins may use BYOK on any workspace (management/testing).
+    const { effectiveSuperUser } = await verifyEffectiveSuperUser(userId)
+    if (effectiveSuperUser) {
+      return new NextResponse(null, { status: 200 })
+    }
+
+    // Everyone else must be a workspace member on an enterprise plan. The
+    // membership check prevents one org from using another org's stored key.
+    const permission = await getUserEntityPermissions(userId, 'workspace', workspaceId)
+    if (!permission) {
+      logger.warn('BYOK validate denied: user is not a member of the workspace', {
+        workspaceId,
+        userId,
+      })
+      return new NextResponse(null, { status: 403 })
+    }
+
+    const eligible = await isWorkspaceOnEnterprisePlan(workspaceId)
+    if (!eligible) {
+      logger.warn('BYOK validate denied: workspace is not on an enterprise plan', { workspaceId })
+      return new NextResponse(null, { status: 403 })
+    }
+
+    return new NextResponse(null, { status: 200 })
+  } catch (error) {
+    logger.error('BYOK validation failed', { error, workspaceId })
+    return NextResponse.json({ error: 'Failed to validate BYOK entitlement' }, { status: 500 })
+  }
+})