@atproto/ozone 0.0.2

package/dist/services/moderation/index.d.ts

@@ -0,0 +1,144 @@
+import { CID } from 'multiformats/cid';
+import { AtUri } from '@atproto/syntax';
+import { Database } from '../../db';
+import { ModerationViews } from './views';
+import { Main as StrongRef } from '../../lexicon/types/com/atproto/repo/strongRef';
+import { RepoRef, RepoBlobRef } from '../../lexicon/types/com/atproto/admin/defs';
+import { ModEventType, ModerationEventRow, ModerationSubjectStatusRow, ReversibleModerationEvent } from './types';
+import { ModerationEvent } from '../../db/schema/moderation_event';
+import AtpAgent from '@atproto/api';
+import { Label } from '../../lexicon/types/com/atproto/label/defs';
+import { ModSubject, RecordSubject, RepoSubject } from './subject';
+export declare class ModerationService {
+    db: Database;
+    appviewAgent: AtpAgent;
+    constructor(db: Database, appviewAgent: AtpAgent);
+    static creator(appviewAgent: AtpAgent): (db: Database) => ModerationService;
+    views: ModerationViews;
+    getEvent(id: number): Promise<ModerationEventRow | undefined>;
+    getEventOrThrow(id: number): Promise<ModerationEventRow>;
+    getEvents(opts: {
+        subject?: string;
+        createdBy?: string;
+        limit: number;
+        cursor?: string;
+        includeAllUserRecords: boolean;
+        types: ModerationEvent['action'][];
+        sortDirection?: 'asc' | 'desc';
+    }): Promise<{
+        cursor?: string;
+        events: ModerationEventRow[];
+    }>;
+    getReport(id: number): Promise<ModerationEventRow | undefined>;
+    getCurrentStatus(subject: {
+        did: string;
+    } | {
+        uri: AtUri;
+    } | {
+        cids: CID[];
+    }): Promise<{
+        did: string;
+        id: number;
+        createdAt: string;
+        updatedAt: string;
+        reviewState: "com.atproto.admin.defs#reviewOpen" | "com.atproto.admin.defs#reviewEscalated" | "com.atproto.admin.defs#reviewClosed";
+        blobCids: string[] | null;
+        comment: string | null;
+        lastReportedAt: string | null;
+        lastReviewedAt: string | null;
+        muteUntil: string | null;
+        lastReviewedBy: string | null;
+        takendown: boolean;
+        suspendUntil: string | null;
+        recordPath: string;
+        recordCid: string | null;
+    }[]>;
+    logEvent(info: {
+        event: ModEventType;
+        subject: ModSubject;
+        createdBy: string;
+        createdAt?: Date;
+    }): Promise<ModerationEventRow>;
+    getLastReversibleEventForSubject(subject: ReversalSubject): Promise<{
+        id: number;
+        createdBy: string;
+        createdAt: string;
+        comment: string | null;
+        createLabelVals: string | null;
+        negateLabelVals: string | null;
+        durationInHours: number | null;
+        action: "com.atproto.admin.defs#modEventTakedown" | "com.atproto.admin.defs#modEventAcknowledge" | "com.atproto.admin.defs#modEventEscalate" | "com.atproto.admin.defs#modEventComment" | "com.atproto.admin.defs#modEventLabel" | "com.atproto.admin.defs#modEventReport" | "com.atproto.admin.defs#modEventMute" | "com.atproto.admin.defs#modEventReverseTakedown" | "com.atproto.admin.defs#modEventEmail";
+        subjectType: "com.atproto.admin.defs#repoRef" | "com.atproto.repo.strongRef";
+        subjectDid: string;
+        subjectUri: string | null;
+        subjectCid: string | null;
+        meta: Record<string, string | boolean> | null;
+        expiresAt: string | null;
+        legacyRefId: number | null;
+    } | null | undefined>;
+    getSubjectsDueForReversal(): Promise<ReversalSubject[]>;
+    isSubjectSuspended(did: string): Promise<boolean>;
+    revertState({ createdBy, createdAt, comment, action, subject, }: ReversibleModerationEvent): Promise<ModerationEventRow>;
+    takedownRepo(subject: RepoSubject, takedownId: number): Promise<void>;
+    reverseTakedownRepo(subject: RepoSubject): Promise<void>;
+    takedownRecord(subject: RecordSubject, takedownId: number): Promise<void>;
+    reverseTakedownRecord(subject: RecordSubject): Promise<void>;
+    report(info: {
+        reasonType: NonNullable<ModerationEventRow['meta']>['reportType'];
+        reason?: string;
+        subject: ModSubject;
+        reportedBy: string;
+        createdAt?: Date;
+    }): Promise<ModerationEventRow>;
+    getSubjectStatuses({ cursor, limit, takendown, reviewState, reviewedAfter, reviewedBefore, reportedAfter, reportedBefore, includeMuted, ignoreSubjects, sortDirection, lastReviewedBy, sortField, subject, }: {
+        cursor?: string;
+        limit?: number;
+        takendown?: boolean;
+        reviewedBefore?: string;
+        reviewState?: ModerationSubjectStatusRow['reviewState'];
+        reviewedAfter?: string;
+        reportedAfter?: string;
+        reportedBefore?: string;
+        includeMuted?: boolean;
+        subject?: string;
+        ignoreSubjects?: string[];
+        sortDirection: 'asc' | 'desc';
+        lastReviewedBy?: string;
+        sortField: 'lastReviewedAt' | 'lastReportedAt';
+    }): Promise<{
+        statuses: {
+            handle: string;
+            did: string;
+            id: number;
+            createdAt: string;
+            updatedAt: string;
+            reviewState: "com.atproto.admin.defs#reviewOpen" | "com.atproto.admin.defs#reviewEscalated" | "com.atproto.admin.defs#reviewClosed";
+            blobCids: string[] | null;
+            comment: string | null;
+            lastReportedAt: string | null;
+            lastReviewedAt: string | null;
+            muteUntil: string | null;
+            lastReviewedBy: string | null;
+            takendown: boolean;
+            suspendUntil: string | null;
+            recordPath: string;
+            recordCid: string | null;
+        }[];
+        cursor: string | undefined;
+    }>;
+    isSubjectTakendown(subject: ModSubject): Promise<boolean>;
+    formatAndCreateLabels(src: string, uri: string, cid: string | null, labels: {
+        create?: string[];
+        negate?: string[];
+    }): Promise<Label[]>;
+    createLabels(labels: Label[]): Promise<void>;
+}
+export declare type TakedownSubjects = {
+    did: string;
+    subjects: (RepoRef | RepoBlobRef | StrongRef)[];
+};
+export declare type ReversalSubject = {
+    subject: ModSubject;
+    reverseSuspend: boolean;
+    reverseMute: boolean;
+};

package/dist/services/moderation/status.d.ts

@@ -0,0 +1,12 @@
+import { AtUri } from '@atproto/syntax';
+import { Database } from '../../db';
+import { ModerationSubjectStatus } from '../../db/schema/moderation_subject_status';
+import { ModerationEventRow } from './types';
+export declare const adjustModerationSubjectStatus: (db: Database, moderationEvent: ModerationEventRow, blobCids?: string[]) => Promise<import("kysely").InsertResult | null>;
+declare type ModerationSubjectStatusFilter = Pick<ModerationSubjectStatus, 'did'> | Pick<ModerationSubjectStatus, 'did' | 'recordPath'> | Pick<ModerationSubjectStatus, 'did' | 'recordPath' | 'recordCid'>;
+export declare const getModerationSubjectStatus: (db: Database, filters: ModerationSubjectStatusFilter) => Promise<{} | undefined>;
+export declare const getStatusIdentifierFromSubject: (subject: string | AtUri) => {
+    did: string;
+    recordPath: string;
+};
+export {};

package/dist/services/moderation/subject.d.ts

@@ -0,0 +1,60 @@
+import { AtUri } from '@atproto/syntax';
+import { InputSchema as ReportInput } from '../../lexicon/types/com/atproto/moderation/createReport';
+import { InputSchema as ActionInput } from '../../lexicon/types/com/atproto/admin/emitModerationEvent';
+import { ModerationEventRow, ModerationSubjectStatusRow } from './types';
+import { RepoRef } from '../../lexicon/types/com/atproto/admin/defs';
+import { Main as StrongRef } from '../../lexicon/types/com/atproto/repo/strongRef';
+declare type SubjectInput = ReportInput['subject'] | ActionInput['subject'];
+export declare const subjectFromInput: (subject: SubjectInput, blobs?: string[]) => ModSubject;
+export declare const subjectFromEventRow: (row: ModerationEventRow) => ModSubject;
+export declare const subjectFromStatusRow: (row: ModerationSubjectStatusRow) => ModSubject;
+declare type SubjectInfo = {
+    subjectType: 'com.atproto.admin.defs#repoRef' | 'com.atproto.repo.strongRef';
+    subjectDid: string;
+    subjectUri: string | null;
+    subjectCid: string | null;
+};
+export interface ModSubject {
+    did: string;
+    recordPath: string | undefined;
+    blobCids?: string[];
+    isRepo(): this is RepoSubject;
+    isRecord(): this is RecordSubject;
+    info(): SubjectInfo;
+    lex(): RepoRef | StrongRef;
+}
+export declare class RepoSubject implements ModSubject {
+    did: string;
+    blobCids: undefined;
+    recordPath: undefined;
+    constructor(did: string);
+    isRepo(): boolean;
+    isRecord(): boolean;
+    isWeakRecord(): boolean;
+    info(): {
+        subjectType: "com.atproto.admin.defs#repoRef";
+        subjectDid: string;
+        subjectUri: null;
+        subjectCid: null;
+    };
+    lex(): RepoRef;
+}
+export declare class RecordSubject implements ModSubject {
+    uri: string;
+    cid: string;
+    blobCids?: string[] | undefined;
+    parsedUri: AtUri;
+    did: string;
+    recordPath: string;
+    constructor(uri: string, cid: string, blobCids?: string[] | undefined);
+    isRepo(): boolean;
+    isRecord(): boolean;
+    info(): {
+        subjectType: "com.atproto.repo.strongRef";
+        subjectDid: string;
+        subjectUri: string;
+        subjectCid: string;
+    };
+    lex(): StrongRef;
+}
+export {};

package/dist/services/moderation/types.d.ts

@@ -0,0 +1,19 @@
+import { Selectable } from 'kysely';
+import { ModerationEvent } from '../../db/schema/moderation_event';
+import { ModerationSubjectStatus } from '../../db/schema/moderation_subject_status';
+import { ComAtprotoAdminDefs } from '@atproto/api';
+import { ModSubject } from './subject';
+export declare type ModerationEventRow = Selectable<ModerationEvent>;
+export declare type ReversibleModerationEvent = Pick<ModerationEventRow, 'createdBy' | 'comment' | 'action'> & {
+    createdAt?: Date;
+    subject: ModSubject;
+};
+export declare type ModerationEventRowWithHandle = ModerationEventRow & {
+    subjectHandle?: string | null;
+    creatorHandle?: string | null;
+};
+export declare type ModerationSubjectStatusRow = Selectable<ModerationSubjectStatus>;
+export declare type ModerationSubjectStatusRowWithHandle = ModerationSubjectStatusRow & {
+    handle: string | null;
+};
+export declare type ModEventType = ComAtprotoAdminDefs.ModEventTakedown | ComAtprotoAdminDefs.ModEventAcknowledge | ComAtprotoAdminDefs.ModEventEscalate | ComAtprotoAdminDefs.ModEventComment | ComAtprotoAdminDefs.ModEventLabel | ComAtprotoAdminDefs.ModEventReport | ComAtprotoAdminDefs.ModEventMute | ComAtprotoAdminDefs.ModEventReverseTakedown;

package/dist/services/moderation/views.d.ts

@@ -0,0 +1,42 @@
+import AtpAgent from '@atproto/api';
+import { BlobRef } from '@atproto/lexicon';
+import { Database } from '../../db';
+import { ModEventView, RepoView, RepoViewDetail, RecordView, RecordViewDetail, ReportViewDetail, BlobView, SubjectStatusView, ModEventViewDetail, AccountView } from '../../lexicon/types/com/atproto/admin/defs';
+import { OutputSchema as ReportOutput } from '../../lexicon/types/com/atproto/moderation/createReport';
+import { Label } from '../../lexicon/types/com/atproto/label/defs';
+import { ModerationEventRowWithHandle, ModerationSubjectStatusRowWithHandle } from './types';
+export declare class ModerationViews {
+    private db;
+    private appviewAgent;
+    constructor(db: Database, appviewAgent: AtpAgent);
+    getAccoutInfosByDid(dids: string[]): Promise<Map<string, AccountView>>;
+    repos(dids: string[]): Promise<Map<string, RepoView>>;
+    formatEvent(event: ModerationEventRowWithHandle): ModEventView;
+    eventDetail(result: ModerationEventRowWithHandle): Promise<ModEventViewDetail>;
+    repoDetail(did: string): Promise<RepoViewDetail | undefined>;
+    fetchRecords(subjects: RecordSubject[]): Promise<Map<string, {
+        uri: string;
+        cid: string;
+        value: Record<string, unknown>;
+        indexedAt: string;
+    }>>;
+    records(subjects: RecordSubject[]): Promise<Map<string, RecordView>>;
+    recordDetail(subject: RecordSubject): Promise<RecordViewDetail | undefined>;
+    formatReport(report: ModerationEventRowWithHandle): ReportOutput;
+    subject(subject: string): Promise<SubjectView>;
+    blob(blobs: BlobRef[]): Promise<BlobView[]>;
+    labels(subject: string, includeNeg?: boolean): Promise<Label[]>;
+    getSubjectStatus(subjects: string[]): Promise<Map<string, ModerationSubjectStatusRowWithHandle>>;
+    formatSubjectStatus(status: ModerationSubjectStatusRowWithHandle): SubjectStatusView;
+}
+declare type RecordSubject = {
+    uri: string;
+    cid?: string;
+};
+declare type SubjectView = ModEventViewDetail['subject'] & ReportViewDetail['subject'];
+export declare function getSelfLabels(details: {
+    uri: string | null;
+    cid: string | null;
+    record: Record<string, unknown> | null;
+}): Label[];
+export {};

package/dist/services/types.d.ts

@@ -0,0 +1,2 @@
+import { Database } from '../db';
+export declare type FromDb<T> = (db: Database) => T;

package/dist/util/date.d.ts

@@ -0,0 +1 @@
+export declare function addHoursToDate(hours: number, startingDate?: Date): Date;

package/dist/util/debug.d.ts

@@ -0,0 +1 @@
+export declare const debugCatch: <Func extends (...args: any[]) => any>(fn: Func) => (...args: Parameters<Func>) => Promise<ReturnType<Func>>;

package/dist/util/retry.d.ts

@@ -0,0 +1,3 @@
+import { RetryOptions } from '@atproto/common';
+export declare function retryHttp<T>(fn: () => Promise<T>, opts?: RetryOptions): Promise<T>;
+export declare function retryableHttp(err: unknown): boolean;

package/dist/util.d.ts

@@ -0,0 +1,3 @@
+import { RetryOptions } from '@atproto/common';
+export declare function retryHttp<T>(fn: () => Promise<T>, opts?: RetryOptions): Promise<T>;
+export declare function retryableHttp(err: unknown): boolean;

package/jest.config.js

@@ -0,0 +1,6 @@
+const base = require('../../jest.config.base.js')
+
+module.exports = {
+  ...base,
+  displayName: 'Bsky App View',
+}

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@atproto/ozone",
+  "version": "0.0.2",
+  "license": "MIT",
+  "description": "Backend service for moderating the Bluesky network.",
+  "keywords": [
+    "atproto",
+    "bluesky"
+  ],
+  "homepage": "https://atproto.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bluesky-social/atproto",
+    "directory": "packages/ozone"
+  },
+  "main": "dist/index.js",
+  "bin": "dist/bin.js",
+  "dependencies": {
+    "@did-plc/lib": "^0.0.1",
+    "compression": "^1.7.4",
+    "cors": "^2.8.5",
+    "express": "^4.17.2",
+    "express-async-errors": "^3.1.1",
+    "http-terminator": "^3.2.0",
+    "kysely": "^0.22.0",
+    "multiformats": "^9.9.0",
+    "p-queue": "^6.6.2",
+    "pg": "^8.10.0",
+    "pino": "^8.15.0",
+    "pino-http": "^8.2.1",
+    "typed-emitter": "^2.1.0",
+    "uint8arrays": "3.0.0",
+    "@atproto/common": "^0.3.3",
+    "@atproto/syntax": "^0.1.5",
+    "@atproto/identity": "^0.3.2",
+    "@atproto/lexicon": "^0.3.1",
+    "@atproto/xrpc-server": "^0.4.2",
+    "@atproto/crypto": "^0.3.0",
+    "@atproto/api": "^0.9.0"
+  },
+  "devDependencies": {
+    "@did-plc/server": "^0.0.1",
+    "@types/cors": "^2.8.12",
+    "@types/express": "^4.17.13",
+    "@types/express-serve-static-core": "^4.17.36",
+    "@types/pg": "^8.6.6",
+    "@types/qs": "^6.9.7",
+    "axios": "^0.27.2",
+    "@atproto/lex-cli": "^0.3.0",
+    "@atproto/api": "^0.9.0",
+    "@atproto/xrpc": "^0.4.1",
+    "@atproto/dev-env": "^0.2.23",
+    "@atproto/pds": "^0.3.11"
+  },
+  "scripts": {
+    "codegen": "lex gen-server ./src/lexicon ../../lexicons/com/atproto/*/* ../../lexicons/app/bsky/*/*",
+    "build": "node ./build.js",
+    "postbuild": "tsc --build tsconfig.build.json",
+    "update-main-to-dist": "node ../../update-main-to-dist.js packages/ozone",
+    "start": "node --enable-source-maps dist/bin.js",
+    "test": "../dev-infra/with-test-redis-and-db.sh jest",
+    "test:log": "tail -50 test.log | pino-pretty",
+    "test:updateSnapshot": "jest --updateSnapshot",
+    "migration:create": "ts-node ./bin/migration-create.ts"
+  },
+  "types": "dist/index.d.ts"
+}

package/src/api/admin/emitModerationEvent.ts

@@ -0,0 +1,130 @@
+import { AuthRequiredError, InvalidRequestError } from '@atproto/xrpc-server'
+import { Server } from '../../lexicon'
+import AppContext from '../../context'
+import {
+  isModEventLabel,
+  isModEventReverseTakedown,
+  isModEventTakedown,
+} from '../../lexicon/types/com/atproto/admin/defs'
+import { subjectFromInput } from '../../mod-service/subject'
+
+export default function (server: Server, ctx: AppContext) {
+  server.com.atproto.admin.emitModerationEvent({
+    auth: ctx.roleVerifier,
+    handler: async ({ input, auth }) => {
+      const access = auth.credentials
+      const db = ctx.db
+      const moderationService = ctx.modService(db)
+      const { createdBy, event } = input.body
+      const isTakedownEvent = isModEventTakedown(event)
+      const isReverseTakedownEvent = isModEventReverseTakedown(event)
+      const isLabelEvent = isModEventLabel(event)
+      const subject = subjectFromInput(
+        input.body.subject,
+        input.body.subjectBlobCids,
+      )
+
+      // apply access rules
+
+      // if less than moderator access then can not takedown an account
+      if (!access.moderator && isTakedownEvent && subject.isRepo()) {
+        throw new AuthRequiredError(
+          'Must be a full moderator to perform an account takedown',
+        )
+      }
+      // if less than moderator access then can only take ack and escalation actions
+      if (!access.moderator && (isTakedownEvent || isReverseTakedownEvent)) {
+        throw new AuthRequiredError(
+          'Must be a full moderator to take this type of action',
+        )
+      }
+      // if less than moderator access then can not apply labels
+      if (!access.moderator && isLabelEvent) {
+        throw new AuthRequiredError('Must be a full moderator to label content')
+      }
+
+      if (isLabelEvent) {
+        validateLabels([
+          ...(event.createLabelVals ?? []),
+          ...(event.negateLabelVals ?? []),
+        ])
+      }
+
+      if (isTakedownEvent || isReverseTakedownEvent) {
+        const isSubjectTakendown = await moderationService.isSubjectTakendown(
+          subject,
+        )
+
+        if (isSubjectTakendown && isTakedownEvent) {
+          throw new InvalidRequestError(`Subject is already taken down`)
+        }
+
+        if (!isSubjectTakendown && isReverseTakedownEvent) {
+          throw new InvalidRequestError(`Subject is not taken down`)
+        }
+      }
+
+      const moderationEvent = await db.transaction(async (dbTxn) => {
+        const moderationTxn = ctx.modService(dbTxn)
+
+        const result = await moderationTxn.logEvent({
+          event,
+          subject,
+          createdBy,
+        })
+
+        if (subject.isRepo()) {
+          if (isTakedownEvent) {
+            const isSuspend = !!result.durationInHours
+            await moderationTxn.takedownRepo(subject, result.id, isSuspend)
+          } else if (isReverseTakedownEvent) {
+            await moderationTxn.reverseTakedownRepo(subject)
+          }
+        }
+
+        if (subject.isRecord()) {
+          if (isTakedownEvent) {
+            await moderationTxn.takedownRecord(subject, result.id)
+          } else if (isReverseTakedownEvent) {
+            await moderationTxn.reverseTakedownRecord(subject)
+          }
+        }
+
+        if (isLabelEvent) {
+          await moderationTxn.formatAndCreateLabels(
+            ctx.cfg.service.did,
+            result.subjectUri ?? result.subjectDid,
+            result.subjectCid,
+            {
+              create: result.createLabelVals?.length
+                ? result.createLabelVals.split(' ')
+                : undefined,
+              negate: result.negateLabelVals?.length
+                ? result.negateLabelVals.split(' ')
+                : undefined,
+            },
+          )
+        }
+
+        return result
+      })
+
+      return {
+        encoding: 'application/json',
+        body: moderationService.views.formatEvent(moderationEvent),
+      }
+    },
+  })
+}
+
+const validateLabels = (labels: string[]) => {
+  for (const label of labels) {
+    for (const char of badChars) {
+      if (label.includes(char)) {
+        throw new InvalidRequestError(`Invalid label: ${label}`)
+      }
+    }
+  }
+}
+
+const badChars = [' ', ',', ';', `'`, `"`]

package/src/api/admin/getModerationEvent.ts

@@ -0,0 +1,19 @@
+import { Server } from '../../lexicon'
+import AppContext from '../../context'
+
+export default function (server: Server, ctx: AppContext) {
+  server.com.atproto.admin.getModerationEvent({
+    auth: ctx.roleVerifier,
+    handler: async ({ params }) => {
+      const { id } = params
+      const db = ctx.db
+      const modService = ctx.modService(db)
+      const event = await modService.getEventOrThrow(id)
+      const eventDetail = await modService.views.eventDetail(event)
+      return {
+        encoding: 'application/json',
+        body: eventDetail,
+      }
+    },
+  })
+}

package/src/api/admin/getRecord.ts

@@ -0,0 +1,34 @@
+import { InvalidRequestError } from '@atproto/xrpc-server'
+import { Server } from '../../lexicon'
+import AppContext from '../../context'
+import { addAccountInfoToRepoView, getPdsAccountInfo } from './util'
+import { AtUri } from '@atproto/syntax'
+
+export default function (server: Server, ctx: AppContext) {
+  server.com.atproto.admin.getRecord({
+    auth: ctx.roleVerifier,
+    handler: async ({ params, auth }) => {
+      const db = ctx.db
+
+      const [record, accountInfo] = await Promise.all([
+        ctx.modService(db).views.recordDetail(params),
+        getPdsAccountInfo(ctx, new AtUri(params.uri).hostname),
+      ])
+
+      if (!record) {
+        throw new InvalidRequestError('Record not found', 'RecordNotFound')
+      }
+
+      record.repo = addAccountInfoToRepoView(
+        record.repo,
+        accountInfo,
+        auth.credentials.moderator,
+      )
+
+      return {
+        encoding: 'application/json',
+        body: record,
+      }
+    },
+  })
+}

package/src/api/admin/getRepo.ts

@@ -0,0 +1,31 @@
+import { InvalidRequestError } from '@atproto/xrpc-server'
+import { Server } from '../../lexicon'
+import AppContext from '../../context'
+import { addAccountInfoToRepoViewDetail, getPdsAccountInfo } from './util'
+
+export default function (server: Server, ctx: AppContext) {
+  server.com.atproto.admin.getRepo({
+    auth: ctx.roleVerifier,
+    handler: async ({ params, auth }) => {
+      const { did } = params
+      const db = ctx.db
+      const [partialRepo, accountInfo] = await Promise.all([
+        ctx.modService(db).views.repoDetail(did),
+        getPdsAccountInfo(ctx, did),
+      ])
+      if (!partialRepo) {
+        throw new InvalidRequestError('Repo not found', 'RepoNotFound')
+      }
+
+      const repo = addAccountInfoToRepoViewDetail(
+        partialRepo,
+        accountInfo,
+        auth.credentials.moderator,
+      )
+      return {
+        encoding: 'application/json',
+        body: repo,
+      }
+    },
+  })
+}

package/src/api/admin/queryModerationEvents.ts

@@ -0,0 +1,40 @@
+import { Server } from '../../lexicon'
+import AppContext from '../../context'
+import { getEventType } from '../moderation/util'
+
+export default function (server: Server, ctx: AppContext) {
+  server.com.atproto.admin.queryModerationEvents({
+    auth: ctx.roleVerifier,
+    handler: async ({ params }) => {
+      const {
+        subject,
+        limit = 50,
+        cursor,
+        sortDirection = 'desc',
+        types,
+        includeAllUserRecords = false,
+        createdBy,
+      } = params
+      const db = ctx.db
+      const modService = ctx.modService(db)
+      const results = await modService.getEvents({
+        types: types?.length ? types.map(getEventType) : [],
+        subject,
+        createdBy,
+        limit,
+        cursor,
+        sortDirection,
+        includeAllUserRecords,
+      })
+      return {
+        encoding: 'application/json',
+        body: {
+          cursor: results.cursor,
+          events: results.events.map((evt) =>
+            modService.views.formatEvent(evt),
+          ),
+        },
+      }
+    },
+  })
+}