@atproto/pds 0.5.11 → 0.5.14

package/src/api/com/atproto/server/deleteSession.ts

@@ -1,23 +0,0 @@
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { com } from '../../../../lexicons/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  const { entrywayClient } = ctx
-
-  if (entrywayClient) {
-    server.add(com.atproto.server.deleteSession, async ({ req }) => {
-      const { headers } = ctx.entrywayPassthruHeaders(req)
-      await entrywayClient.xrpc(com.atproto.server.deleteSession, {
-        headers,
-      })
-    })
-  } else {
-    server.add(com.atproto.server.deleteSession, {
-      auth: ctx.authVerifier.refresh({ allowExpired: true }),
-      handler: async ({ auth }) => {
-        await ctx.accountManager.revokeRefreshToken(auth.credentials.tokenId)
-      },
-    })
-  }
-}

package/src/api/com/atproto/server/describeServer.ts

@@ -1,29 +0,0 @@
-import { UriString } from '@atproto/lex'
-import { DidString } from '@atproto/syntax'
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { com } from '../../../../lexicons/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(com.atproto.server.describeServer, () => {
-    const did = ctx.cfg.service.did as DidString
-    const availableUserDomains = ctx.cfg.identity.serviceHandleDomains
-    const inviteCodeRequired = ctx.cfg.invites.required
-    const privacyPolicy = ctx.cfg.service.privacyPolicyUrl as UriString
-    const termsOfService = ctx.cfg.service.termsOfServiceUrl as UriString
-    const contactEmailAddress = ctx.cfg.service.contactEmailAddress
-
-    return {
-      encoding: 'application/json' as const,
-      body: {
-        did,
-        availableUserDomains,
-        inviteCodeRequired,
-        links: { privacyPolicy, termsOfService },
-        contact: {
-          email: contactEmailAddress,
-        },
-      },
-    }
-  })
-}

package/src/api/com/atproto/server/getAccountInviteCodes.ts

@@ -1,142 +0,0 @@
-import {
-  ForbiddenError,
-  InvalidRequestError,
-  Server,
-} from '@atproto/xrpc-server'
-import { CodeDetail } from '../../../../account-manager/helpers/invite.js'
-import { ACCESS_FULL } from '../../../../auth-scope.js'
-import { AppContext } from '../../../../context.js'
-import { com } from '../../../../lexicons/index.js'
-import { genInvCodes } from './util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(com.atproto.server.getAccountInviteCodes, {
-    auth: ctx.authVerifier.authorization({
-      checkTakedown: true,
-      scopes: ACCESS_FULL,
-      authorize: () => {
-        throw new ForbiddenError(
-          'OAuth credentials are not supported for this endpoint',
-        )
-      },
-    }),
-    handler: async ({ params, auth, req }) => {
-      if (ctx.entrywayClient) {
-        const { headers } = await ctx.entrywayAuthHeaders(
-          req,
-          auth.credentials.did,
-          com.atproto.server.getAccountInviteCodes.$lxm,
-        )
-        return ctx.entrywayClient.xrpc(
-          com.atproto.server.getAccountInviteCodes,
-          { params, headers },
-        )
-      }
-
-      const requester = auth.credentials.did
-      const { includeUsed, createAvailable } = params
-
-      const [account, userCodes] = await Promise.all([
-        ctx.accountManager.getAccount(requester),
-        ctx.accountManager.getAccountInvitesCodes(requester),
-      ])
-      if (!account) {
-        throw new InvalidRequestError('Account not found', 'NotFound')
-      }
-
-      let created: CodeDetail[] = []
-
-      if (
-        createAvailable &&
-        ctx.cfg.invites.required &&
-        ctx.cfg.invites.interval !== null
-      ) {
-        const { toCreate, total } = calculateCodesToCreate({
-          did: requester,
-          userCreatedAt: new Date(account.createdAt).getTime(),
-          codes: userCodes,
-          epoch: ctx.cfg.invites.epoch,
-          interval: ctx.cfg.invites.interval,
-        })
-        if (toCreate > 0) {
-          const codes = genInvCodes(ctx.cfg, toCreate)
-          created = await ctx.accountManager.createAccountInviteCodes(
-            requester,
-            codes,
-            total,
-            account.invitesDisabled ?? 0,
-          )
-        }
-      }
-
-      const allCodes = [...userCodes, ...created]
-
-      const filtered = allCodes.filter((code) => {
-        if (code.disabled) return false
-        if (!includeUsed && code.uses.length >= code.available) return false
-        return true
-      })
-
-      return {
-        encoding: 'application/json' as const,
-        body: { codes: filtered },
-      }
-    },
-  })
-}
-
-/**
- * WARNING: TRICKY SUBTLE MATH - DONT MESS WITH THIS FUNCTION UNLESS YOUR'RE VERY CONFIDENT
- * if the user wishes to create available codes & the server allows that,
- * we determine the number to create by dividing their account lifetime by the interval at which they can create codes
- * if an invite epoch is provided, we only calculate available invites since that epoch
- * we allow a max of 5 open codes at a given time
- * note: even if a user is disabled from future invites, we still create the invites for bookkeeping, we just immediately disable them as well
- */
-const calculateCodesToCreate = (opts: {
-  did: string
-  userCreatedAt: number
-  codes: CodeDetail[]
-  epoch: number
-  interval: number
-}): { toCreate: number; total: number } => {
-  // for the sake of generating routine interval codes, we do not count explicitly gifted admin codes
-  const routineCodes = opts.codes.filter((code) => code.createdBy !== 'admin')
-  const unusedRoutineCodes = routineCodes.filter(
-    (row) => !row.disabled && row.available > row.uses.length,
-  )
-
-  const userLifespan = Date.now() - opts.userCreatedAt
-
-  // how many codes a user could create within the current epoch if they have 0
-  let couldCreate: number
-
-  if (opts.userCreatedAt >= opts.epoch) {
-    // if the user was created after the epoch, then they can create a code for each interval since the epoch
-    couldCreate = Math.floor(userLifespan / opts.interval)
-  } else {
-    // if the user was created before the epoch, we:
-    // - calculate the total intervals since account creation
-    // - calculate the total intervals before the epoch
-    // - subtract the two
-    const couldCreateTotal = Math.floor(userLifespan / opts.interval)
-    const userPreEpochLifespan = opts.epoch - opts.userCreatedAt
-    const couldCreateBeforeEpoch = Math.floor(
-      userPreEpochLifespan / opts.interval,
-    )
-    couldCreate = couldCreateTotal - couldCreateBeforeEpoch
-  }
-  // we count the codes that the user has created within the current epoch
-  const epochCodes = routineCodes.filter(
-    (code) => new Date(code.createdAt).getTime() > opts.epoch,
-  )
-  // finally we the number of codes they currently have from the number that they could create, and take a max of 5
-  const toCreate = Math.min(
-    5 - unusedRoutineCodes.length,
-    couldCreate - epochCodes.length,
-  )
-  return {
-    toCreate,
-    total: routineCodes.length + toCreate,
-  }
-}

package/src/api/com/atproto/server/getServiceAuth.ts

@@ -1,111 +0,0 @@
-import { HOUR, MINUTE } from '@atproto/common'
-import { isAtprotoDid, isAtprotoDidRefAbsolute } from '@atproto/did'
-import { l } from '@atproto/lex'
-import {
-  InvalidRequestError,
-  Server,
-  createServiceJwt,
-} from '@atproto/xrpc-server'
-import {
-  AuthScope,
-  isAccessPrivileged,
-  isTakendown,
-} from '../../../../auth-scope.js'
-import { AppContext } from '../../../../context.js'
-import { com } from '../../../../lexicons/index.js'
-import {
-  PRIVILEGED_METHODS,
-  PROTECTED_METHODS,
-} from '../../../../pipethrough.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(com.atproto.server.getServiceAuth, {
-    auth: ctx.authVerifier.authorization<
-      l.InferMethodParams<typeof com.atproto.server.getServiceAuth.main>
-    >({
-      additional: [AuthScope.Takendown],
-      authorize: (permissions, { params }) => {
-        const { aud, lxm = '*' } = params
-        permissions.assertRpc({ aud, lxm })
-      },
-    }),
-    handler: async ({ params, auth }) => {
-      const did = auth.credentials.did
-
-      // @NOTE "exp" is expressed in seconds since epoch, not milliseconds
-      const { aud, exp, lxm = null } = params
-
-      if (!isAtprotoDid(aud) && !isAtprotoDidRefAbsolute(aud)) {
-        throw new InvalidRequestError(
-          'aud must be a valid atproto DID or did#serviceId reference',
-        )
-      }
-
-      // Takendown accounts should not be able to generate service auth tokens except for methods necessary for account migration
-      if (auth.credentials.type === 'access') {
-        // @NOTE We should probably use "ForbiddenError" here. Using
-        // "InvalidRequestError" for legacy reasons.
-        if (
-          isTakendown(auth.credentials.scope) &&
-          lxm !== com.atproto.server.createAccount.$lxm
-        ) {
-          throw new InvalidRequestError('Bad token scope', 'InvalidToken')
-        }
-
-        // @NOTE "oauth" based credentials already checked through permission
-        // set in "authorize" method above.
-        if (
-          lxm != null &&
-          PRIVILEGED_METHODS.has(lxm) &&
-          !isAccessPrivileged(auth.credentials.scope)
-        ) {
-          throw new InvalidRequestError(
-            `insufficient access to request a service auth token for the following method: ${lxm}`,
-          )
-        }
-      }
-
-      if (exp) {
-        const diff = exp * 1000 - Date.now()
-        if (diff < 0) {
-          throw new InvalidRequestError(
-            'expiration is in past',
-            'BadExpiration',
-          )
-        } else if (diff > HOUR) {
-          throw new InvalidRequestError(
-            'cannot request a token with an expiration more than an hour in the future',
-            'BadExpiration',
-          )
-        } else if (!lxm && diff > MINUTE) {
-          throw new InvalidRequestError(
-            'cannot request a method-less token with an expiration more than a minute in the future',
-            'BadExpiration',
-          )
-        }
-      }
-
-      if (lxm && PROTECTED_METHODS.has(lxm)) {
-        throw new InvalidRequestError(
-          `cannot request a service auth token for the following protected method: ${lxm}`,
-        )
-      }
-
-      const keypair = await ctx.actorStore.keypair(did)
-
-      const token = await createServiceJwt({
-        iss: did,
-        aud,
-        exp,
-        lxm,
-        keypair,
-      })
-      return {
-        encoding: 'application/json' as const,
-        body: {
-          token,
-        },
-      }
-    },
-  })
-}

package/src/api/com/atproto/server/getSession.ts

@@ -1,80 +0,0 @@
-import { DidString, HandleString, INVALID_HANDLE } from '@atproto/syntax'
-import { InvalidRequestError, Server } from '@atproto/xrpc-server'
-import { formatAccountStatus } from '../../../../account-manager/account-manager.js'
-import { AccessOutput, OAuthOutput } from '../../../../auth-output.js'
-import { AuthScope } from '../../../../auth-scope.js'
-import { AppContext } from '../../../../context.js'
-import { com } from '../../../../lexicons/index.js'
-import { didDocForSession } from './util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(com.atproto.server.getSession, {
-    auth: ctx.authVerifier.authorization({
-      additional: [AuthScope.SignupQueued],
-      authorize: () => {
-        // Always allowed. "email" access is checked in the handler.
-      },
-    }),
-    handler: async ({ auth, req }) => {
-      if (ctx.entrywayClient) {
-        const { headers } = await ctx.entrywayAuthHeaders(
-          req,
-          auth.credentials.did,
-          'com.atproto.server.getSession',
-        )
-
-        const { body } = await ctx.entrywayClient.xrpc(
-          com.atproto.server.getSession,
-          { headers },
-        )
-
-        return {
-          encoding: 'application/json' as const,
-          body: output(auth, body),
-        }
-      }
-
-      const did = auth.credentials.did
-      const [user, didDoc] = await Promise.all([
-        ctx.accountManager.getAccount(did, { includeDeactivated: true }),
-        didDocForSession(ctx, did),
-      ])
-      if (!user) {
-        throw new InvalidRequestError(
-          `Could not find user info for account: ${did}`,
-        )
-      }
-
-      const { status, active } = formatAccountStatus(user)
-
-      return {
-        encoding: 'application/json' as const,
-        body: output(auth, {
-          did: user.did as DidString,
-          // @ts-expect-error https://github.com/bluesky-social/atproto/pull/4406
-          didDoc,
-          handle: (user.handle ?? INVALID_HANDLE) as HandleString,
-          email: user.email ?? undefined,
-          emailConfirmed: !!user.emailConfirmedAt,
-          active,
-          status,
-        }),
-      }
-    },
-  })
-}
-
-function output(
-  { credentials }: OAuthOutput | AccessOutput,
-  data: com.atproto.server.getSession.$OutputBody,
-): com.atproto.server.getSession.$OutputBody {
-  if (
-    credentials.type === 'oauth' &&
-    !credentials.permissions.allowsAccount({ attr: 'email', action: 'read' })
-  ) {
-    const { email, emailAuthFactor, emailConfirmed, ...rest } = data
-    return rest
-  }
-
-  return data
-}

package/src/api/com/atproto/server/index.ts

@@ -1,55 +0,0 @@
-import { Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import activateAccount from './activateAccount.js'
-import checkAccountStatus from './checkAccountStatus.js'
-import confirmEmail from './confirmEmail.js'
-import createAccount from './createAccount.js'
-import createAppPassword from './createAppPassword.js'
-import createInviteCode from './createInviteCode.js'
-import createInviteCodes from './createInviteCodes.js'
-import createSession from './createSession.js'
-import deactivateAccount from './deactivateAccount.js'
-import deleteAccount from './deleteAccount.js'
-import deleteSession from './deleteSession.js'
-import describeServer from './describeServer.js'
-import getAccountInviteCodes from './getAccountInviteCodes.js'
-import getServiceAuth from './getServiceAuth.js'
-import getSession from './getSession.js'
-import listAppPasswords from './listAppPasswords.js'
-import refreshSession from './refreshSession.js'
-import requestDelete from './requestAccountDelete.js'
-import requestEmailConfirmation from './requestEmailConfirmation.js'
-import requestEmailUpdate from './requestEmailUpdate.js'
-import requestPasswordReset from './requestPasswordReset.js'
-import reserveSigningKey from './reserveSigningKey.js'
-import resetPassword from './resetPassword.js'
-import revokeAppPassword from './revokeAppPassword.js'
-import updateEmail from './updateEmail.js'
-
-export default function (server: Server, ctx: AppContext) {
-  describeServer(server, ctx)
-  createAccount(server, ctx)
-  createInviteCode(server, ctx)
-  createInviteCodes(server, ctx)
-  getAccountInviteCodes(server, ctx)
-  reserveSigningKey(server, ctx)
-  requestDelete(server, ctx)
-  deleteAccount(server, ctx)
-  requestPasswordReset(server, ctx)
-  resetPassword(server, ctx)
-  requestEmailConfirmation(server, ctx)
-  confirmEmail(server, ctx)
-  requestEmailUpdate(server, ctx)
-  updateEmail(server, ctx)
-  createSession(server, ctx)
-  deleteSession(server, ctx)
-  getSession(server, ctx)
-  refreshSession(server, ctx)
-  createAppPassword(server, ctx)
-  listAppPasswords(server, ctx)
-  revokeAppPassword(server, ctx)
-  getServiceAuth(server, ctx)
-  checkAccountStatus(server, ctx)
-  activateAccount(server, ctx)
-  deactivateAccount(server, ctx)
-}

package/src/api/com/atproto/server/listAppPasswords.ts

@@ -1,45 +0,0 @@
-import { ForbiddenError, Server } from '@atproto/xrpc-server'
-import { AppContext } from '../../../../context.js'
-import { com } from '../../../../lexicons/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  const { entrywayClient } = ctx
-
-  const auth = ctx.authVerifier.authorization({
-    authorize: () => {
-      throw new ForbiddenError(
-        'OAuth credentials are not supported for this endpoint',
-      )
-    },
-  })
-
-  if (entrywayClient) {
-    server.add(com.atproto.server.listAppPasswords, {
-      auth,
-      handler: async ({ auth, req }) => {
-        const { headers } = await ctx.entrywayAuthHeaders(
-          req,
-          auth.credentials.did,
-          com.atproto.server.listAppPasswords.$lxm,
-        )
-
-        return entrywayClient.xrpc(com.atproto.server.listAppPasswords, {
-          headers,
-        })
-      },
-    })
-  } else {
-    server.add(com.atproto.server.listAppPasswords, {
-      auth,
-      handler: async ({ auth }) => {
-        const passwords = await ctx.accountManager.listAppPasswords(
-          auth.credentials.did,
-        )
-        return {
-          encoding: 'application/json',
-          body: { passwords },
-        }
-      },
-    })
-  }
-}

package/src/api/com/atproto/server/refreshSession.ts

@@ -1,72 +0,0 @@
-import { DidString, HandleString, INVALID_HANDLE } from '@atproto/syntax'
-import {
-  AuthRequiredError,
-  InvalidRequestError,
-  Server,
-} from '@atproto/xrpc-server'
-import { formatAccountStatus } from '../../../../account-manager/account-manager.js'
-import { AppContext } from '../../../../context.js'
-import { softDeleted } from '../../../../db/util.js'
-import { com } from '../../../../lexicons/index.js'
-import { didDocForSession } from './util.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(com.atproto.server.refreshSession, {
-    auth: ctx.authVerifier.refresh(),
-    handler: async ({
-      auth,
-      req,
-    }): Promise<com.atproto.server.refreshSession.$Output> => {
-      const did = auth.credentials.did
-      const user = await ctx.accountManager.getAccount(did, {
-        includeDeactivated: true,
-        includeTakenDown: true,
-      })
-      if (!user) {
-        throw new InvalidRequestError(
-          `Could not find user info for account: ${did}`,
-        )
-      }
-      if (softDeleted(user)) {
-        throw new AuthRequiredError(
-          'Account has been taken down',
-          'AccountTakedown',
-        )
-      }
-
-      if (ctx.entrywayClient) {
-        const { headers } = ctx.entrywayPassthruHeaders(req)
-        return ctx.entrywayClient.xrpc(com.atproto.server.refreshSession, {
-          headers,
-        })
-      }
-
-      const [didDoc, rotated] = await Promise.all([
-        didDocForSession(ctx, user.did),
-        ctx.accountManager.rotateRefreshToken(auth.credentials.tokenId),
-      ])
-      if (rotated === null) {
-        throw new InvalidRequestError('Token has been revoked', 'ExpiredToken')
-      }
-
-      const { status, active } = formatAccountStatus(user)
-
-      return {
-        encoding: 'application/json' as const,
-        body: {
-          accessJwt: rotated.accessJwt,
-          refreshJwt: rotated.refreshJwt,
-
-          did: user.did as DidString,
-          // @ts-expect-error https://github.com/bluesky-social/atproto/pull/4406
-          didDoc,
-          handle: (user.handle ?? INVALID_HANDLE) as HandleString,
-          email: user.email ?? undefined,
-          emailConfirmed: !!user.emailConfirmedAt,
-          active,
-          status,
-        },
-      }
-    },
-  })
-}

package/src/api/com/atproto/server/requestAccountDelete.ts

@@ -1,66 +0,0 @@
-import { DAY, HOUR } from '@atproto/common'
-import {
-  ForbiddenError,
-  InvalidRequestError,
-  Server,
-} from '@atproto/xrpc-server'
-import { ACCESS_FULL } from '../../../../auth-scope.js'
-import { AppContext } from '../../../../context.js'
-import { com } from '../../../../lexicons/index.js'
-
-export default function (server: Server, ctx: AppContext) {
-  server.add(com.atproto.server.requestAccountDelete, {
-    rateLimit: [
-      {
-        durationMs: DAY,
-        points: 15,
-        calcKey: ({ auth }) => auth.credentials.did,
-      },
-      {
-        durationMs: HOUR,
-        points: 5,
-        calcKey: ({ auth }) => auth.credentials.did,
-      },
-    ],
-    auth: ctx.authVerifier.authorization({
-      checkTakedown: true,
-      scopes: ACCESS_FULL,
-      authorize: () => {
-        throw new ForbiddenError(
-          'OAuth credentials are not supported for this endpoint',
-        )
-      },
-    }),
-    handler: async ({ auth, req }) => {
-      const did = auth.credentials.did
-      const account = await ctx.accountManager.getAccount(did, {
-        includeDeactivated: true,
-        includeTakenDown: true,
-      })
-      if (!account) {
-        throw new InvalidRequestError('account not found')
-      }
-
-      if (ctx.entrywayClient) {
-        const { headers } = await ctx.entrywayAuthHeaders(
-          req,
-          auth.credentials.did,
-          com.atproto.server.requestAccountDelete.$lxm,
-        )
-        await ctx.entrywayClient.xrpc(com.atproto.server.requestAccountDelete, {
-          headers,
-        })
-        return
-      }
-
-      if (!account.email) {
-        throw new InvalidRequestError('account does not have an email address')
-      }
-      const token = await ctx.accountManager.createEmailToken(
-        did,
-        'delete_account',
-      )
-      await ctx.mailer.sendAccountDelete({ token }, { to: account.email })
-    },
-  })
-}