Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
17.6 KB
Raw Blame
import { and, eq, inArray, isNull } from "@omnirush-ee/den-db/drizzle"
import {
  ConfigObjectAccessGrantTable,
  ConfigObjectTable,
  ConnectorInstanceAccessGrantTable,
  ConnectorInstanceTable,
  MarketplaceAccessGrantTable,
  MarketplacePluginTable,
  MarketplaceTable,
  PluginAccessGrantTable,
  PluginConfigObjectTable,
  PluginTable,
} from "@omnirush-ee/den-db/schema"
import type { MemberTeamSummary, OrganizationContext } from "../../../orgs.js"
import { db } from "../../../db.js"
import { getFreshPrivilegedSessionRequiredResponse, hasFreshPrivilegedSession, memberHasRole } from "../shared.js"

export type PluginArchResourceKind = "config_object" | "connector_instance" | "marketplace" | "plugin"
export type PluginArchRole = "viewer" | "editor" | "manager"
export type PluginArchCapability = "config_object.create" | "connector_account.create" | "connector_instance.create" | "marketplace.create" | "plugin.create"

export type PluginArchActorContext = {
  apiKey?: true
  automation?: true
  memberTeams: MemberTeamSummary[]
  organizationContext: OrganizationContext
  session: { createdAt?: Date | string | null } | null | undefined
}

type MemberId = OrganizationContext["currentMember"]["id"]
type TeamId = MemberTeamSummary["id"]
type OrganizationId = OrganizationContext["organization"]["id"]
type ConfigObjectId = typeof ConfigObjectTable.$inferSelect.id
type MarketplaceId = typeof MarketplaceTable.$inferSelect.id
type PluginId = typeof PluginTable.$inferSelect.id
type ConnectorInstanceId = typeof ConnectorInstanceTable.$inferSelect.id
type ConfigObjectGrantRow = Pick<typeof ConfigObjectAccessGrantTable.$inferSelect, "orgMembershipId" | "orgWide" | "removedAt" | "role" | "teamId">
type MarketplaceGrantRow = Pick<typeof MarketplaceAccessGrantTable.$inferSelect, "orgMembershipId" | "orgWide" | "removedAt" | "role" | "teamId">
type PluginGrantRow = Pick<typeof PluginAccessGrantTable.$inferSelect, "orgMembershipId" | "orgWide" | "removedAt" | "role" | "teamId">
type ConnectorInstanceGrantRow = Pick<typeof ConnectorInstanceAccessGrantTable.$inferSelect, "orgMembershipId" | "orgWide" | "removedAt" | "role" | "teamId">
type GrantRow = ConfigObjectGrantRow | MarketplaceGrantRow | PluginGrantRow | ConnectorInstanceGrantRow
type ExposureGrantRow = Pick<PluginGrantRow, "orgMembershipId" | "orgWide" | "teamId">

type MarketplaceResourceLookupInput = {
  context: PluginArchActorContext
  resourceId: MarketplaceId
  resourceKind: "marketplace"
}

type PluginResourceLookupInput = {
  context: PluginArchActorContext
  resourceId: PluginId
  resourceKind: "plugin"
}

type ConnectorInstanceResourceLookupInput = {
  context: PluginArchActorContext
  resourceId: ConnectorInstanceId
  resourceKind: "connector_instance"
}

type ConfigObjectResourceLookupInput = {
  context: PluginArchActorContext
  resourceId: ConfigObjectId
  resourceKind: "config_object"
}

type ResourceLookupInput =
  | PluginResourceLookupInput
  | ConnectorInstanceResourceLookupInput
  | MarketplaceResourceLookupInput
  | ConfigObjectResourceLookupInput

type ExposureResourceLookupInput = PluginResourceLookupInput | ConfigObjectResourceLookupInput

type RequireResourceRoleInput = ResourceLookupInput & {
  requireFreshSession?: boolean
  role: PluginArchRole
}

export class PluginArchAuthorizationError extends Error {
  constructor(
    readonly status: 403,
    readonly error: "forbidden" | "reauth",
    message: string,
    readonly reason?: string,
  ) {
    super(message)
    this.name = "PluginArchAuthorizationError"
  }
}

const rolePriority: Record<PluginArchRole, number> = {
  viewer: 1,
  editor: 2,
  manager: 3,
}

function maxRole(current: PluginArchRole | null, candidate: PluginArchRole | null) {
  if (!candidate) return current
  if (!current) return candidate
  return rolePriority[candidate] > rolePriority[current] ? candidate : current
}

export function isPluginArchOrgAdmin(context: PluginArchActorContext) {
  return context.organizationContext.currentMember.isOwner || memberHasRole(context.organizationContext.currentMember.role, "admin")
}

export function hasPluginArchCapability(context: PluginArchActorContext, capability: PluginArchCapability) {
  if (capability === "plugin.create" || capability === "config_object.create") {
    return true
  }
  return isPluginArchOrgAdmin(context)
}

function ensureFreshPluginArchAdmin(context: PluginArchActorContext, sessionMaxAgeMs?: number) {
  if (context.apiKey === true || context.automation === true) {
    // Session freshness is a step-up check for interactive humans. API keys and connector automation
    // are non-interactive principals authorized by their scoped organization membership.
    return
  }
  if (!isPluginArchOrgAdmin(context) || hasFreshPrivilegedSession({ session: context.session }, new Date(), sessionMaxAgeMs)) {
    return
  }

  const response = getFreshPrivilegedSessionRequiredResponse()
  throw new PluginArchAuthorizationError(403, response.error, response.message, response.reason)
}

function roleSatisfies(role: PluginArchRole | null, required: PluginArchRole) {
  if (!role) return false
  return rolePriority[role] >= rolePriority[required]
}

async function filterPluginIdsInOrganization(organizationId: OrganizationId, pluginIds: PluginId[]) {
  if (pluginIds.length === 0) {
    return []
  }

  const rows = await db
    .select({ id: PluginTable.id })
    .from(PluginTable)
    .where(and(eq(PluginTable.organizationId, organizationId), inArray(PluginTable.id, pluginIds)))

  return rows.map((row) => row.id)
}

async function filterMarketplaceIdsInOrganization(organizationId: OrganizationId, marketplaceIds: MarketplaceId[]) {
  if (marketplaceIds.length === 0) {
    return []
  }

  const rows = await db
    .select({ id: MarketplaceTable.id })
    .from(MarketplaceTable)
    .where(and(eq(MarketplaceTable.organizationId, organizationId), inArray(MarketplaceTable.id, marketplaceIds)))

  return rows.map((row) => row.id)
}

async function resourceExistsInOrganization(input: ResourceLookupInput) {
  const organizationId = input.context.organizationContext.organization.id

  if (input.resourceKind === "marketplace") {
    const rows = await db
      .select({ id: MarketplaceTable.id })
      .from(MarketplaceTable)
      .where(and(eq(MarketplaceTable.organizationId, organizationId), eq(MarketplaceTable.id, input.resourceId)))
      .limit(1)
    return Boolean(rows[0])
  }

  if (input.resourceKind === "plugin") {
    const rows = await db
      .select({ id: PluginTable.id })
      .from(PluginTable)
      .where(and(eq(PluginTable.organizationId, organizationId), eq(PluginTable.id, input.resourceId)))
      .limit(1)
    return Boolean(rows[0])
  }

  if (input.resourceKind === "connector_instance") {
    const rows = await db
      .select({ id: ConnectorInstanceTable.id })
      .from(ConnectorInstanceTable)
      .where(and(eq(ConnectorInstanceTable.organizationId, organizationId), eq(ConnectorInstanceTable.id, input.resourceId)))
      .limit(1)
    return Boolean(rows[0])
  }

  const rows = await db
    .select({ id: ConfigObjectTable.id })
    .from(ConfigObjectTable)
    .where(and(eq(ConfigObjectTable.organizationId, organizationId), eq(ConfigObjectTable.id, input.resourceId)))
    .limit(1)
  return Boolean(rows[0])
}

export function resolvePluginArchGrantRole(input: {
  grants: GrantRow[]
  memberId: MemberId
  teamIds: TeamId[]
}) {
  const teamIds = new Set(input.teamIds)
  let resolved: PluginArchRole | null = null

  for (const grant of input.grants) {
    if (grant.removedAt) continue
    const applies = grant.orgWide || grant.orgMembershipId === input.memberId || (grant.teamId ? teamIds.has(grant.teamId) : false)
    if (!applies) continue
    resolved = maxRole(resolved, grant.role)
  }

  return resolved
}

export function pluginArchGrantExpandsAudience(grant: ExposureGrantRow, memberId: MemberId) {
  return grant.orgWide
    || grant.teamId !== null
    || (grant.orgMembershipId !== null && grant.orgMembershipId !== memberId)
}

async function pluginIdsHaveExpandedAudience(context: PluginArchActorContext, pluginIds: PluginId[]) {
  if (pluginIds.length === 0) return false

  const organizationId = context.organizationContext.organization.id
  const memberId = context.organizationContext.currentMember.id
  const grants = await db
    .select({
      orgMembershipId: PluginAccessGrantTable.orgMembershipId,
      orgWide: PluginAccessGrantTable.orgWide,
      teamId: PluginAccessGrantTable.teamId,
    })
    .from(PluginAccessGrantTable)
    .where(and(
      eq(PluginAccessGrantTable.organizationId, organizationId),
      inArray(PluginAccessGrantTable.pluginId, pluginIds),
      isNull(PluginAccessGrantTable.removedAt),
    ))
  if (grants.some((grant) => pluginArchGrantExpandsAudience(grant, memberId))) return true

  const marketplaceMemberships = await db
    .select({ id: MarketplacePluginTable.id })
    .from(MarketplacePluginTable)
    .where(and(
      eq(MarketplacePluginTable.organizationId, organizationId),
      inArray(MarketplacePluginTable.pluginId, pluginIds),
      isNull(MarketplacePluginTable.removedAt),
    ))
  return marketplaceMemberships.length > 0
}

export async function pluginArchResourceHasExpandedAudience(input: ExposureResourceLookupInput) {
  if (input.resourceKind === "plugin") {
    return pluginIdsHaveExpandedAudience(input.context, [input.resourceId])
  }

  const organizationId = input.context.organizationContext.organization.id
  const memberId = input.context.organizationContext.currentMember.id
  const grants = await db
    .select({
      orgMembershipId: ConfigObjectAccessGrantTable.orgMembershipId,
      orgWide: ConfigObjectAccessGrantTable.orgWide,
      teamId: ConfigObjectAccessGrantTable.teamId,
    })
    .from(ConfigObjectAccessGrantTable)
    .where(and(
      eq(ConfigObjectAccessGrantTable.organizationId, organizationId),
      eq(ConfigObjectAccessGrantTable.configObjectId, input.resourceId),
      isNull(ConfigObjectAccessGrantTable.removedAt),
    ))
  if (grants.some((grant) => pluginArchGrantExpandsAudience(grant, memberId))) return true

  const memberships = await db
    .select({ pluginId: PluginConfigObjectTable.pluginId })
    .from(PluginConfigObjectTable)
    .where(and(
      eq(PluginConfigObjectTable.organizationId, organizationId),
      eq(PluginConfigObjectTable.configObjectId, input.resourceId),
      isNull(PluginConfigObjectTable.removedAt),
    ))
  return pluginIdsHaveExpandedAudience(input.context, memberships.map((membership) => membership.pluginId))
}

async function resolveGrantRole(input: {
  grants: GrantRow[]
  context: PluginArchActorContext
}) {
  return resolvePluginArchGrantRole({
    grants: input.grants,
    memberId: input.context.organizationContext.currentMember.id,
    teamIds: input.context.memberTeams.map((team) => team.id),
  })
}

async function resolvePluginRoleForIds(context: PluginArchActorContext, pluginIds: PluginId[]) {
  const organizationPluginIds = await filterPluginIdsInOrganization(context.organizationContext.organization.id, pluginIds)
  if (organizationPluginIds.length === 0) {
    return null
  }

  if (isPluginArchOrgAdmin(context)) {
    return "manager" satisfies PluginArchRole
  }

  const grants = await db
    .select({
      orgMembershipId: PluginAccessGrantTable.orgMembershipId,
      orgWide: PluginAccessGrantTable.orgWide,
      removedAt: PluginAccessGrantTable.removedAt,
      role: PluginAccessGrantTable.role,
      teamId: PluginAccessGrantTable.teamId,
    })
    .from(PluginAccessGrantTable)
    .where(and(
      inArray(PluginAccessGrantTable.pluginId, organizationPluginIds),
      eq(PluginAccessGrantTable.organizationId, context.organizationContext.organization.id),
    ))

  return resolveGrantRole({ context, grants })
}

async function resolveMarketplaceRoleForIds(context: PluginArchActorContext, marketplaceIds: MarketplaceId[]) {
  const organizationMarketplaceIds = await filterMarketplaceIdsInOrganization(context.organizationContext.organization.id, marketplaceIds)
  if (organizationMarketplaceIds.length === 0) {
    return null
  }

  if (isPluginArchOrgAdmin(context)) {
    return "manager" satisfies PluginArchRole
  }

  const grants = await db
    .select({
      orgMembershipId: MarketplaceAccessGrantTable.orgMembershipId,
      orgWide: MarketplaceAccessGrantTable.orgWide,
      removedAt: MarketplaceAccessGrantTable.removedAt,
      role: MarketplaceAccessGrantTable.role,
      teamId: MarketplaceAccessGrantTable.teamId,
    })
    .from(MarketplaceAccessGrantTable)
    .where(and(
      inArray(MarketplaceAccessGrantTable.marketplaceId, organizationMarketplaceIds),
      eq(MarketplaceAccessGrantTable.organizationId, context.organizationContext.organization.id),
    ))

  return resolveGrantRole({ context, grants })
}

export async function resolvePluginArchResourceRole(input: ResourceLookupInput) {
  if (!(await resourceExistsInOrganization(input))) {
    return null
  }

  if (isPluginArchOrgAdmin(input.context)) {
    return "manager" satisfies PluginArchRole
  }

  if (input.resourceKind === "marketplace") {
    const grants = await db
      .select({
        orgMembershipId: MarketplaceAccessGrantTable.orgMembershipId,
        orgWide: MarketplaceAccessGrantTable.orgWide,
        removedAt: MarketplaceAccessGrantTable.removedAt,
        role: MarketplaceAccessGrantTable.role,
        teamId: MarketplaceAccessGrantTable.teamId,
      })
      .from(MarketplaceAccessGrantTable)
      .where(and(
        eq(MarketplaceAccessGrantTable.marketplaceId, input.resourceId),
        eq(MarketplaceAccessGrantTable.organizationId, input.context.organizationContext.organization.id),
      ))
    return resolveGrantRole({ context: input.context, grants })
  }

  if (input.resourceKind === "plugin") {
    const grants = await db
      .select({
        orgMembershipId: PluginAccessGrantTable.orgMembershipId,
        orgWide: PluginAccessGrantTable.orgWide,
        removedAt: PluginAccessGrantTable.removedAt,
        role: PluginAccessGrantTable.role,
        teamId: PluginAccessGrantTable.teamId,
      })
      .from(PluginAccessGrantTable)
      .where(and(
        eq(PluginAccessGrantTable.pluginId, input.resourceId),
        eq(PluginAccessGrantTable.organizationId, input.context.organizationContext.organization.id),
      ))
    const resolved = await resolveGrantRole({ context: input.context, grants })
    if (resolved) {
      return resolved
    }

    const memberships = await db
      .select({ marketplaceId: MarketplacePluginTable.marketplaceId })
      .from(MarketplacePluginTable)
      .where(and(eq(MarketplacePluginTable.pluginId, input.resourceId), isNull(MarketplacePluginTable.removedAt)))

    const marketplaceRole = await resolveMarketplaceRoleForIds(input.context, memberships.map((membership) => membership.marketplaceId))
    return maxRole(resolved, marketplaceRole ? "viewer" : null)
  }

  if (input.resourceKind === "connector_instance") {
    const grants = await db
      .select({
        orgMembershipId: ConnectorInstanceAccessGrantTable.orgMembershipId,
        orgWide: ConnectorInstanceAccessGrantTable.orgWide,
        removedAt: ConnectorInstanceAccessGrantTable.removedAt,
        role: ConnectorInstanceAccessGrantTable.role,
        teamId: ConnectorInstanceAccessGrantTable.teamId,
      })
      .from(ConnectorInstanceAccessGrantTable)
      .where(and(
        eq(ConnectorInstanceAccessGrantTable.connectorInstanceId, input.resourceId),
        eq(ConnectorInstanceAccessGrantTable.organizationId, input.context.organizationContext.organization.id),
      ))
    return resolveGrantRole({ context: input.context, grants })
  }

  const directGrants = await db
    .select({
      orgMembershipId: ConfigObjectAccessGrantTable.orgMembershipId,
      orgWide: ConfigObjectAccessGrantTable.orgWide,
      removedAt: ConfigObjectAccessGrantTable.removedAt,
      role: ConfigObjectAccessGrantTable.role,
      teamId: ConfigObjectAccessGrantTable.teamId,
    })
    .from(ConfigObjectAccessGrantTable)
    .where(and(
      eq(ConfigObjectAccessGrantTable.configObjectId, input.resourceId),
      eq(ConfigObjectAccessGrantTable.organizationId, input.context.organizationContext.organization.id),
    ))

  let resolved = await resolveGrantRole({ context: input.context, grants: directGrants })
  if (resolved) {
    return resolved
  }

  const memberships = await db
    .select({ pluginId: PluginConfigObjectTable.pluginId })
    .from(PluginConfigObjectTable)
    .where(and(eq(PluginConfigObjectTable.configObjectId, input.resourceId), isNull(PluginConfigObjectTable.removedAt)))

  const pluginRole = await resolvePluginRoleForIds(input.context, memberships.map((membership) => membership.pluginId))
  resolved = maxRole(resolved, pluginRole ? "viewer" : null)
  return resolved
}

export async function requirePluginArchCapability(context: PluginArchActorContext, capability: PluginArchCapability, requireFreshSession?: boolean) {
  if (hasPluginArchCapability(context, capability)) {
    if (requireFreshSession !== false) ensureFreshPluginArchAdmin(context)
    return
  }

  throw new PluginArchAuthorizationError(403, "forbidden", `Missing organization capability: ${capability}`)
}

export async function requirePluginArchResourceRole(input: {
  context: PluginArchActorContext
  requireFreshSession?: boolean
  sessionMaxAgeMs?: number
  resourceId: ConfigObjectId | ConnectorInstanceId | MarketplaceId | PluginId
  resourceKind: PluginArchResourceKind
  role: PluginArchRole
}) {
  if (input.role !== "viewer" && input.requireFreshSession !== false) {
    ensureFreshPluginArchAdmin(input.context, input.sessionMaxAgeMs)
  }

  const resolved = await resolvePluginArchResourceRole(input as RequireResourceRoleInput)
  if (roleSatisfies(resolved, input.role)) {
    return resolved
  }

  throw new PluginArchAuthorizationError(
    403,
    "forbidden",
    `Missing ${input.role} access for ${input.resourceKind.replace(/_/g, " ")}.`,
  )
}