A desktop coding agent with free access to frontier models.
TypeScript
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,
}
}