Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
5.9 KB
Raw Blame
import { and, eq, isNull, sql } from "@omnirush-ee/den-db/drizzle"
import { MemberTable, OrganizationTable, WorkerTable } from "@omnirush-ee/den-db/schema"
import { ManagedModelsPolicyError, readOrganizationMetadata } from "@omnirush/types/den/managed-models-policy"
import { db } from "./db.js"
import { updateOrganizationMetadata } from "./organization-metadata.js"

export const DEFAULT_ORGANIZATION_LIMITS = {
  members: 5,
  workers: 1,
} as const

export type OrganizationLimitType = keyof typeof DEFAULT_ORGANIZATION_LIMITS

export type OrganizationLimits = {
  members: number
  workers: number
}

export type ManagedBrandAssetMetadata = {
  kind: "logo" | "icon"
  version: string
  extension: "png" | "jpg"
  contentType: "image/png" | "image/jpeg"
  url: string
  width: number
  height: number
  byteLength: number
  originalName: string
  uploadedAt: string
}

type OrganizationId = typeof OrganizationTable.$inferSelect.id

export type OrganizationMetadata = {
  limits: OrganizationLimits
  seatsFreeAdditional?: number
  allowedDesktopVersions?: string[]
  requireSso?: boolean
  brandAppName?: string
  brandLogoUrl?: string
  brandIconUrl?: string
  brandLogoAsset?: ManagedBrandAssetMetadata
  brandIconAsset?: ManagedBrandAssetMetadata
  brandAccentColor?: string
} & Record<string, unknown>

type OrganizationMetadataInput = Record<string, unknown> | string | null | undefined

function isRecord(value: unknown): value is Record<string, unknown> {
  return typeof value === "object" && value !== null && !Array.isArray(value)
}

function normalizePositiveInteger(value: unknown, fallback: number) {
  if (typeof value === "number" && Number.isInteger(value) && value > 0) {
    return value
  }

  if (typeof value === "string") {
    const parsed = Number(value)
    if (Number.isInteger(parsed) && parsed > 0) {
      return parsed
    }
  }

  return fallback
}

function normalizeDesktopVersionString(value: unknown) {
  if (typeof value !== "string") {
    return null
  }

  const normalized = value.trim().replace(/^v/i, "")
  return /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(normalized)
    ? normalized
    : null
}

function normalizeAllowedDesktopVersions(value: unknown): string[] | null {
  if (!Array.isArray(value)) {
    return null
  }

  const versions = [...new Set(value.map((entry) => normalizeDesktopVersionString(entry)).filter((entry): entry is string => Boolean(entry)))]
  return versions
}

function sameStringArray(left: string[] | null, right: string[] | null) {
  if (left === right) {
    return true
  }

  if (!left || !right || left.length !== right.length) {
    return false
  }

  return left.every((entry, index) => right[index] === entry)
}

export function normalizeOrganizationMetadata(input: OrganizationMetadataInput): {
  metadata: OrganizationMetadata
  changed: boolean
} {
  const parsed = readOrganizationMetadata(input)
  const rawLimits = isRecord(parsed.limits) ? parsed.limits : null
  const allowedDesktopVersions = normalizeAllowedDesktopVersions(parsed.allowedDesktopVersions)
  const members = normalizePositiveInteger(rawLimits?.members, DEFAULT_ORGANIZATION_LIMITS.members)
  const workers = normalizePositiveInteger(rawLimits?.workers ?? rawLimits?.Workers, DEFAULT_ORGANIZATION_LIMITS.workers)

  const metadata: OrganizationMetadata = {
    ...parsed,
    limits: {
      ...rawLimits,
      members,
      workers,
    },
    ...(allowedDesktopVersions !== null ? { allowedDesktopVersions } : {}),
  }

  if (allowedDesktopVersions === null) {
    delete metadata.allowedDesktopVersions
  }

  const rawAllowedDesktopVersions = Array.isArray(parsed.allowedDesktopVersions)
    ? parsed.allowedDesktopVersions.filter((entry): entry is string => typeof entry === "string")
    : null

  const changed =
    !isRecord(parsed.limits) ||
    Object.keys(parsed).length === 0 ||
    rawLimits?.members !== members ||
    (rawLimits?.workers ?? rawLimits?.Workers) !== workers ||
    !sameStringArray(rawAllowedDesktopVersions, allowedDesktopVersions)

  return { metadata, changed }
}

export function serializeOrganizationMetadata(metadata: OrganizationMetadataInput) {
  const parsed = readOrganizationMetadata(metadata)
  return Object.keys(parsed).length > 0 ? JSON.stringify(parsed) : null
}

export async function getOrInitializeOrganizationMetadata(organizationId: OrganizationId) {
  const rows = await db
    .select({ metadata: OrganizationTable.metadata })
    .from(OrganizationTable)
    .where(eq(OrganizationTable.id, organizationId))
    .limit(1)

  if (!rows[0]) throw new ManagedModelsPolicyError("managed_models_policy_unavailable")
  const { metadata, changed } = normalizeOrganizationMetadata(rows[0].metadata)
  if (changed) {
    const updated = await updateOrganizationMetadata(organizationId, (current) => normalizeOrganizationMetadata(current).metadata)
    return normalizeOrganizationMetadata(updated).metadata
  }

  return metadata
}

async function countOrganizationMembers(organizationId: OrganizationId) {
  const rows = await db
    .select({ count: sql<number>`count(*)` })
    .from(MemberTable)
    .where(and(eq(MemberTable.organizationId, organizationId), isNull(MemberTable.removedAt)))

  return Number(rows[0]?.count ?? 0)
}

async function countOrganizationWorkers(organizationId: OrganizationId) {
  const rows = await db
    .select({ count: sql<number>`count(*)` })
    .from(WorkerTable)
    .where(eq(WorkerTable.org_id, organizationId))

  return Number(rows[0]?.count ?? 0)
}

export async function getOrganizationLimitStatus(organizationId: OrganizationId, limitType: OrganizationLimitType) {
  const metadata = await getOrInitializeOrganizationMetadata(organizationId)
  const currentCount =
    limitType === "members"
      ? await countOrganizationMembers(organizationId)
      : await countOrganizationWorkers(organizationId)

  const limit = metadata.limits[limitType]

  return {
    metadata,
    currentCount,
    limit,
    exceeded: currentCount >= limit,
  }
}