A desktop coding agent with free access to frontier models.
TypeScript
import { createHmac, timingSafeEqual } from "node:crypto"
import { eq, sql } from "@omnirush-ee/den-db/drizzle"
import { AdminAllowlistTable, AuthSessionTable, AuthUserTable } from "@omnirush-ee/den-db/schema"
import { createDenTypeId, normalizeDenTypeId } from "@omnirush-ee/utils/typeid"
import { cache } from "./cache.js"
import { db } from "./db.js"
import { env } from "./env.js"
import { ensureSingletonOrganizationForUser, setSessionActiveOrganization } from "./orgs.js"
export const INITIAL_ADMIN_BOOTSTRAP_GRANT_PREFIX = "ow_bootstrap_"
const INITIAL_ADMIN_BOOTSTRAP_GRANT_TTL_MS = 10 * 60 * 1000
const BOOTSTRAPPED_ADMIN_NOTE = "Initial administrator bootstrap"
const GENERIC_BOOTSTRAP_REJECTION = "Setup could not be verified. Check the administrator email and one-time setup code."
type BootstrapStatus = "available" | "complete" | "unavailable"
export type InitialAdminBootstrapAvailability = {
status: BootstrapStatus
reason: "ready" | "complete" | "not_configured" | "users_exist"
}
type BootstrapGrant = {
email: string
expiresAt: number
}
export function normalizeInitialAdminBootstrapEmail(email: string) {
return email.trim().toLowerCase()
}
function configuredBootstrapEmails() {
const ownerEmails = env.singleOrg.ownerEmails.map(normalizeInitialAdminBootstrapEmail).filter(Boolean)
const fallbackAdminEmails = env.bootstrapAdminEmails.map(normalizeInitialAdminBootstrapEmail).filter(Boolean)
return Array.from(new Set(ownerEmails.length > 0 ? ownerEmails : fallbackAdminEmails))
}
export function isInitialAdminBootstrapEmailConfigured(email: string) {
const normalized = normalizeInitialAdminBootstrapEmail(email)
return normalized.length > 0 && configuredBootstrapEmails().includes(normalized)
}
export function compareInitialAdminBootstrapCode(submittedCode: string, expectedCode: string) {
const expected = new Uint8Array(Buffer.from(expectedCode, "utf8"))
const actual = new Uint8Array(Buffer.from(submittedCode, "utf8"))
return actual.length === expected.length && timingSafeEqual(actual, expected)
}
function hasUsableBootstrapConfiguration() {
if (configuredBootstrapEmails().length === 0) {
return { ok: false as const, reason: "not_configured" as const }
}
if (!env.initialAdminBootstrapCode) {
return { ok: false as const, reason: "not_configured" as const }
}
return { ok: true as const, code: env.initialAdminBootstrapCode }
}
async function anyAuthUserExists() {
const rows = await db.select({ id: AuthUserTable.id }).from(AuthUserTable).limit(1)
return Boolean(rows[0])
}
export async function getInitialAdminBootstrapAvailability(): Promise<InitialAdminBootstrapAvailability> {
if (await anyAuthUserExists()) {
return { status: "complete", reason: "users_exist" }
}
const config = hasUsableBootstrapConfiguration()
if (!config.ok) {
return { status: "unavailable", reason: config.reason }
}
return { status: "available", reason: "ready" }
}
function signGrantPayload(payload: string) {
return createHmac("sha256", env.betterAuthSecret).update(payload).digest("base64url")
}
function encodeGrant(input: BootstrapGrant) {
const payload = Buffer.from(JSON.stringify(input), "utf8").toString("base64url")
return `${INITIAL_ADMIN_BOOTSTRAP_GRANT_PREFIX}${payload}.${signGrantPayload(payload)}`
}
function decodeGrant(grant: string): BootstrapGrant | null {
if (!isInitialAdminBootstrapGrantFormat(grant)) {
return null
}
const unsigned = grant.slice(INITIAL_ADMIN_BOOTSTRAP_GRANT_PREFIX.length)
const [payload, signature, ...extra] = unsigned.split(".")
if (!payload || !signature || extra.length > 0) {
return null
}
const expected = signGrantPayload(payload)
const actualSignature = new Uint8Array(Buffer.from(signature, "base64url"))
const expectedSignature = new Uint8Array(Buffer.from(expected, "base64url"))
if (actualSignature.length !== expectedSignature.length || !timingSafeEqual(actualSignature, expectedSignature)) {
return null
}
try {
const parsed: unknown = JSON.parse(Buffer.from(payload, "base64url").toString("utf8"))
if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
return null
}
const email = Object.getOwnPropertyDescriptor(parsed, "email")?.value
const expiresAt = Object.getOwnPropertyDescriptor(parsed, "expiresAt")?.value
return typeof email === "string" && Number.isSafeInteger(expiresAt)
? { email, expiresAt }
: null
} catch {
return null
}
}
export async function verifyInitialAdminBootstrap(input: {
email: string
code: string
}) {
const normalizedEmail = normalizeInitialAdminBootstrapEmail(input.email)
const availability = await getInitialAdminBootstrapAvailability()
if (availability.status !== "available") {
return { ok: false as const, status: 409, message: "Initial administrator setup is not available." }
}
const config = hasUsableBootstrapConfiguration()
if (!config.ok || !isInitialAdminBootstrapEmailConfigured(normalizedEmail)) {
return { ok: false as const, status: 403, message: GENERIC_BOOTSTRAP_REJECTION }
}
if (!compareInitialAdminBootstrapCode(input.code, config.code)) {
return { ok: false as const, status: 403, message: GENERIC_BOOTSTRAP_REJECTION }
}
const expiresAt = new Date(Date.now() + INITIAL_ADMIN_BOOTSTRAP_GRANT_TTL_MS)
const grant = encodeGrant({ email: normalizedEmail, expiresAt: expiresAt.getTime() })
return { ok: true as const, grant, expiresAt }
}
function readStringProperty(value: unknown, propertyName: string) {
if (!value || typeof value !== "object") {
return null
}
const property = Object.getOwnPropertyDescriptor(value, propertyName)?.value
return typeof property === "string" && property.trim() ? property.trim() : null
}
export function readInitialAdminBootstrapGrantFromBody(body: unknown) {
return readStringProperty(body, "bootstrapGrant")
}
export function isInitialAdminBootstrapGrantFormat(value: string) {
return value.startsWith(INITIAL_ADMIN_BOOTSTRAP_GRANT_PREFIX) && value.length > INITIAL_ADMIN_BOOTSTRAP_GRANT_PREFIX.length
}
export async function authorizeInitialAdminBootstrapSignup(input: {
body: unknown
email: string | null
}) {
const grantToken = readInitialAdminBootstrapGrantFromBody(input.body)
if (!grantToken) {
return null
}
const grant = decodeGrant(grantToken)
const normalizedEmail = input.email ? normalizeInitialAdminBootstrapEmail(input.email) : ""
if (!grant || grant.email !== normalizedEmail || grant.expiresAt <= Date.now() || !isInitialAdminBootstrapEmailConfigured(normalizedEmail)) {
return null
}
const availability = await getInitialAdminBootstrapAvailability()
return availability.status === "available" ? { email: normalizedEmail } : null
}
export function initialAdminBootstrapSignupRejectedResponse() {
return Response.json({ error: "bootstrap_verification_failed", message: GENERIC_BOOTSTRAP_REJECTION }, { status: 403 })
}
async function readSessionByToken(token: string) {
const rows = await db
.select({ id: AuthSessionTable.id, userId: AuthSessionTable.userId, activeOrganizationId: AuthSessionTable.activeOrganizationId })
.from(AuthSessionTable)
.where(eq(AuthSessionTable.token, token))
.limit(1)
return rows[0] ?? null
}
function readAuthResponseToken(payload: unknown) {
const token = readStringProperty(payload, "token") ?? readStringProperty(payload, "sessionToken")
if (token) {
return token
}
const session = !payload || typeof payload !== "object" ? null : Object.getOwnPropertyDescriptor(payload, "session")?.value
return readStringProperty(session, "token")
}
async function ensureBootstrappedPlatformAdmin(email: string) {
await db
.insert(AdminAllowlistTable)
.values({
id: createDenTypeId("adminAllowlist"),
email,
note: BOOTSTRAPPED_ADMIN_NOTE,
})
.onDuplicateKeyUpdate({
set: { note: BOOTSTRAPPED_ADMIN_NOTE, updated_at: sql`CURRENT_TIMESTAMP(3)` },
})
}
export async function completeInitialAdminBootstrapSignup(input: {
grant: { email: string }
response: Response
}) {
if (!input.response.ok) {
return input.response
}
const payload: unknown = await input.response.clone().json().catch(() => null)
const token = readAuthResponseToken(payload)
if (!token) {
return input.response
}
const session = await readSessionByToken(token)
if (!session) {
return input.response
}
const organizationId = await ensureSingletonOrganizationForUser(session.userId, { forceOwner: true })
if (organizationId && session.activeOrganizationId !== organizationId) {
await setSessionActiveOrganization(normalizeDenTypeId("session", session.id), organizationId)
} else {
await cache.auth.deleteSession(token)
}
await ensureBootstrappedPlatformAdmin(input.grant.email)
return input.response
}