Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
9.9 KB
Raw Blame
import { and, eq, inArray, isNull, or } from "@omnirush-ee/den-db/drizzle"
import {
  LlmProviderAccessTable,
  LlmProviderModelTable,
  LlmProviderTable,
  MemberTable,
  TeamMemberTable,
} from "@omnirush-ee/den-db/schema"
import { normalizeDenTypeId } from "@omnirush-ee/utils/typeid"
import { AUTOMATION_FREE_MODEL } from "@omnirush/types/automations"
import { INFERENCE_MODEL_ALIASES } from "@omnirush/types/den/inference"
import { db } from "../db.js"
import { organizationAllowsManagedModels } from "../inference.js"
import { calculateDesktopPolicyForOrgMember } from "../desktop-policies.js"

type ProviderId = typeof LlmProviderTable.$inferSelect.id
type MemberId = typeof MemberTable.$inferSelect.id

export type AutomationAuthorityMember = {
  id: MemberId
}

export type AutomationAuthorityProvider = {
  id: ProviderId
  source: "models_dev" | "custom" | "omnirush"
  name: string
}

export type AutomationAuthorityModel = {
  modelId: string
  name: string
}

export type AutomationModelSelection = {
  providerId: string
  modelId: string
}

export type ResolvedAutomationModel = AutomationModelSelection & {
  accessKind: "free" | "omnirush_managed" | "authorized_custom"
  providerRecordId: string | null
  providerName: string
  modelName: string
}

export type AutomationAuthorityFailure = {
  ok: false
  code: "owner_membership_lost" | "model_access_lost" | "provider_unavailable"
  message: string
}

export type AutomationAuthorityResult =
  | { ok: true; value: ResolvedAutomationModel }
  | AutomationAuthorityFailure

export type AutomationModelAuthorityStore = {
  findActiveMember(input: { organizationId: string; ownerMemberId: string }): Promise<AutomationAuthorityMember | null>
  findOmniRushProvider(input: { organizationId: string; ownerMemberId: string }): Promise<AutomationAuthorityProvider | null>
  findProvider(input: { organizationId: string; providerId: string }): Promise<AutomationAuthorityProvider | null>
  findModel(input: { providerRecordId: ProviderId; modelId: string }): Promise<AutomationAuthorityModel | null>
  canAccessProvider(input: { member: AutomationAuthorityMember; providerRecordId: ProviderId }): Promise<boolean>
  allowsZenModel(input: { organizationId: string; ownerMemberId: string }): Promise<boolean>
}

const databaseAuthorityStore: AutomationModelAuthorityStore = {
  async findActiveMember(input) {
    const members = await db.select().from(MemberTable).where(and(
      eq(MemberTable.id, normalizeDenTypeId("member", input.ownerMemberId)),
      eq(MemberTable.organizationId, normalizeDenTypeId("organization", input.organizationId)),
      isNull(MemberTable.removedAt),
    )).limit(1)
    return members[0] ?? null
  },

  async findOmniRushProvider(input) {
    if (!await organizationAllowsManagedModels(normalizeDenTypeId("organization", input.organizationId))) return null
    const providers = await db.select().from(LlmProviderTable).where(and(
      eq(LlmProviderTable.organizationId, normalizeDenTypeId("organization", input.organizationId)),
      eq(LlmProviderTable.createdByOrgMembershipId, normalizeDenTypeId("member", input.ownerMemberId)),
      eq(LlmProviderTable.source, "omnirush"),
      eq(LlmProviderTable.providerId, "omnirush"),
    )).limit(1)
    return providers[0] ?? null
  },

  async findProvider(input) {
    let providerId: ProviderId
    try {
      providerId = normalizeDenTypeId("llmProvider", input.providerId)
    } catch {
      return null
    }
    const providers = await db.select().from(LlmProviderTable).where(and(
      eq(LlmProviderTable.id, providerId),
      eq(LlmProviderTable.organizationId, normalizeDenTypeId("organization", input.organizationId)),
    )).limit(1)
    return providers[0] ?? null
  },

  async findModel(input) {
    const models = await db.select().from(LlmProviderModelTable).where(and(
      eq(LlmProviderModelTable.llmProviderId, normalizeDenTypeId("llmProvider", input.providerRecordId)),
      eq(LlmProviderModelTable.modelId, input.modelId),
    )).limit(1)
    return models[0] ?? null
  },

  async canAccessProvider(input) {
    const teamRows = await db.select({ id: TeamMemberTable.teamId }).from(TeamMemberTable)
      .where(eq(TeamMemberTable.orgMembershipId, input.member.id))
    const teamIds = teamRows.map((row) => row.id)
    const grants = await db.select({ id: LlmProviderAccessTable.id }).from(LlmProviderAccessTable).where(and(
      eq(LlmProviderAccessTable.llmProviderId, normalizeDenTypeId("llmProvider", input.providerRecordId)),
      or(
        eq(LlmProviderAccessTable.orgMembershipId, input.member.id),
        ...(teamIds.length > 0 ? [inArray(LlmProviderAccessTable.teamId, teamIds)] : []),
        and(isNull(LlmProviderAccessTable.orgMembershipId), isNull(LlmProviderAccessTable.teamId)),
      ),
    )).limit(1)
    return Boolean(grants[0])
  },

  async allowsZenModel(input) {
    const policy = await calculateDesktopPolicyForOrgMember({
      organizationId: normalizeDenTypeId("organization", input.organizationId),
      orgMemberId: normalizeDenTypeId("member", input.ownerMemberId),
    })
    return policy.allowZenModel
  },
}

function enabledOmniRushModel(modelId: string) {
  const model = Object.entries(INFERENCE_MODEL_ALIASES)
    .find(([candidate]) => candidate === modelId)?.[1]
  return model?.enabled === true ? model : null
}

function resolvedProviderModel(input: {
  accessKind: ResolvedAutomationModel["accessKind"]
  providerId: string
  modelId: string
  provider: AutomationAuthorityProvider
  model: AutomationAuthorityModel
}): ResolvedAutomationModel {
  return {
    accessKind: input.accessKind,
    providerRecordId: input.provider.id,
    providerId: input.providerId,
    modelId: input.modelId,
    providerName: input.provider.name,
    modelName: input.model.name,
  }
}

export async function resolveAutomationModelAccessWithStore(
  input: { organizationId: string; ownerMemberId: string } & AutomationModelSelection,
  store: AutomationModelAuthorityStore,
): Promise<AutomationAuthorityResult> {
  const member = await store.findActiveMember(input)
  if (!member) {
    return { ok: false, code: "owner_membership_lost", message: "The Automation owner is no longer an active organization member." }
  }

  if (input.providerId === AUTOMATION_FREE_MODEL.providerId) {
    if (input.modelId !== AUTOMATION_FREE_MODEL.modelId) {
      return { ok: false, code: "model_access_lost", message: "The selected free model is not available for Automations." }
    }
    if (!await store.allowsZenModel(input)) {
      return {
        ok: false,
        code: "model_access_lost",
        message: "The selected OpenCode Zen model is no longer available. Choose a supported model to resume this Automation.",
      }
    }
    return {
      ok: true,
      value: {
        accessKind: "free",
        providerRecordId: null,
        providerId: input.providerId,
        modelId: input.modelId,
        providerName: AUTOMATION_FREE_MODEL.providerName,
        modelName: AUTOMATION_FREE_MODEL.modelName,
      },
    }
  }

  if (input.providerId === "omnirush") {
    const model = enabledOmniRushModel(input.modelId)
    if (!model) {
      return { ok: false, code: "model_access_lost", message: "The selected OmniRush.ai-managed model is not available." }
    }
    const provider = await store.findOmniRushProvider(input)
    if (!provider) {
      return { ok: false, code: "provider_unavailable", message: "OmniRush.ai Models are not available for the Automation owner." }
    }
    if (!await store.canAccessProvider({ member, providerRecordId: provider.id })) {
      return { ok: false, code: "model_access_lost", message: "The Automation owner no longer has access to OmniRush.ai Models." }
    }
    return {
      ok: true,
      value: {
        accessKind: "omnirush_managed",
        providerRecordId: provider.id,
        providerId: input.providerId,
        modelId: input.modelId,
        providerName: provider.name,
        modelName: model.displayName.replace(/^OmniRush.ai:\s*/, ""),
      },
    }
  }

  const provider = await store.findProvider(input)
  if (!provider || provider.source === "omnirush") {
    return { ok: false, code: "provider_unavailable", message: "The selected model provider is no longer available." }
  }
  const model = await store.findModel({ providerRecordId: provider.id, modelId: input.modelId })
  if (!model) {
    return { ok: false, code: "model_access_lost", message: "The selected model is no longer available from this provider." }
  }
  if (!await store.canAccessProvider({ member, providerRecordId: provider.id })) {
    return { ok: false, code: "model_access_lost", message: "The Automation owner no longer has access to the selected model." }
  }
  return { ok: true, value: resolvedProviderModel({ accessKind: "authorized_custom", providerId: input.providerId, modelId: input.modelId, provider, model }) }
}

export async function isActiveAutomationOwnerWithStore(
  input: { organizationId: string; ownerMemberId: string },
  store: AutomationModelAuthorityStore,
): Promise<boolean> {
  return Boolean(await store.findActiveMember(input))
}

/**
 * Runner tokens outlive membership changes (12h HMAC credentials with no
 * server-side state), so every runner request re-checks that the owner is
 * still an active member before honoring the token.
 */
export function isActiveAutomationOwner(
  input: { organizationId: string; ownerMemberId: string },
): Promise<boolean> {
  return isActiveAutomationOwnerWithStore(input, databaseAuthorityStore)
}

export function resolveAutomationModelAccess(input: {
  organizationId: string
  ownerMemberId: string
  providerId: string
  modelId: string
}): Promise<AutomationAuthorityResult> {
  return resolveAutomationModelAccessWithStore(input, databaseAuthorityStore)
}

export async function requireAutomationModelAccess(input: Parameters<typeof resolveAutomationModelAccess>[0]): Promise<ResolvedAutomationModel> {
  const result = await resolveAutomationModelAccess(input)
  if (!result.ok) {
    const error = new Error(result.message)
    error.name = result.code
    throw error
  }
  return result.value
}