@atproto/bsky 0.0.10 → 0.0.11

package/dist/lexicon/index.d.ts

@@ -29,6 +29,7 @@ import * as ComAtprotoRepoGetRecord from './types/com/atproto/repo/getRecord';
 import * as ComAtprotoRepoListRecords from './types/com/atproto/repo/listRecords';
 import * as ComAtprotoRepoPutRecord from './types/com/atproto/repo/putRecord';
 import * as ComAtprotoRepoUploadBlob from './types/com/atproto/repo/uploadBlob';
+import * as ComAtprotoServerConfirmEmail from './types/com/atproto/server/confirmEmail';
 import * as ComAtprotoServerCreateAccount from './types/com/atproto/server/createAccount';
 import * as ComAtprotoServerCreateAppPassword from './types/com/atproto/server/createAppPassword';
 import * as ComAtprotoServerCreateInviteCode from './types/com/atproto/server/createInviteCode';
@@ -42,9 +43,12 @@ import * as ComAtprotoServerGetSession from './types/com/atproto/server/getSessi
 import * as ComAtprotoServerListAppPasswords from './types/com/atproto/server/listAppPasswords';
 import * as ComAtprotoServerRefreshSession from './types/com/atproto/server/refreshSession';
 import * as ComAtprotoServerRequestAccountDelete from './types/com/atproto/server/requestAccountDelete';
+import * as ComAtprotoServerRequestEmailConfirmation from './types/com/atproto/server/requestEmailConfirmation';
+import * as ComAtprotoServerRequestEmailUpdate from './types/com/atproto/server/requestEmailUpdate';
 import * as ComAtprotoServerRequestPasswordReset from './types/com/atproto/server/requestPasswordReset';
 import * as ComAtprotoServerResetPassword from './types/com/atproto/server/resetPassword';
 import * as ComAtprotoServerRevokeAppPassword from './types/com/atproto/server/revokeAppPassword';
+import * as ComAtprotoServerUpdateEmail from './types/com/atproto/server/updateEmail';
 import * as ComAtprotoSyncGetBlob from './types/com/atproto/sync/getBlob';
 import * as ComAtprotoSyncGetBlocks from './types/com/atproto/sync/getBlocks';
 import * as ComAtprotoSyncGetCheckout from './types/com/atproto/sync/getCheckout';
@@ -196,6 +200,7 @@ export declare class RepoNS {
 export declare class ServerNS {
     _server: Server;
     constructor(server: Server);
+    confirmEmail<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerConfirmEmail.Handler<ExtractAuth<AV>>, ComAtprotoServerConfirmEmail.HandlerReqCtx<ExtractAuth<AV>>>): void;
     createAccount<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerCreateAccount.Handler<ExtractAuth<AV>>, ComAtprotoServerCreateAccount.HandlerReqCtx<ExtractAuth<AV>>>): void;
     createAppPassword<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerCreateAppPassword.Handler<ExtractAuth<AV>>, ComAtprotoServerCreateAppPassword.HandlerReqCtx<ExtractAuth<AV>>>): void;
     createInviteCode<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerCreateInviteCode.Handler<ExtractAuth<AV>>, ComAtprotoServerCreateInviteCode.HandlerReqCtx<ExtractAuth<AV>>>): void;
@@ -209,9 +214,12 @@ export declare class ServerNS {
     listAppPasswords<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerListAppPasswords.Handler<ExtractAuth<AV>>, ComAtprotoServerListAppPasswords.HandlerReqCtx<ExtractAuth<AV>>>): void;
     refreshSession<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerRefreshSession.Handler<ExtractAuth<AV>>, ComAtprotoServerRefreshSession.HandlerReqCtx<ExtractAuth<AV>>>): void;
     requestAccountDelete<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerRequestAccountDelete.Handler<ExtractAuth<AV>>, ComAtprotoServerRequestAccountDelete.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    requestEmailConfirmation<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerRequestEmailConfirmation.Handler<ExtractAuth<AV>>, ComAtprotoServerRequestEmailConfirmation.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    requestEmailUpdate<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerRequestEmailUpdate.Handler<ExtractAuth<AV>>, ComAtprotoServerRequestEmailUpdate.HandlerReqCtx<ExtractAuth<AV>>>): void;
     requestPasswordReset<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerRequestPasswordReset.Handler<ExtractAuth<AV>>, ComAtprotoServerRequestPasswordReset.HandlerReqCtx<ExtractAuth<AV>>>): void;
     resetPassword<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerResetPassword.Handler<ExtractAuth<AV>>, ComAtprotoServerResetPassword.HandlerReqCtx<ExtractAuth<AV>>>): void;
     revokeAppPassword<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerRevokeAppPassword.Handler<ExtractAuth<AV>>, ComAtprotoServerRevokeAppPassword.HandlerReqCtx<ExtractAuth<AV>>>): void;
+    updateEmail<AV extends AuthVerifier>(cfg: ConfigOf<AV, ComAtprotoServerUpdateEmail.Handler<ExtractAuth<AV>>, ComAtprotoServerUpdateEmail.HandlerReqCtx<ExtractAuth<AV>>>): void;
 }
 export declare class SyncNS {
     _server: Server;

package/dist/lexicon/lexicons.d.ts

@@ -2060,6 +2060,34 @@ export declare const schemaDict: {
             };
         };
     };
+    ComAtprotoServerConfirmEmail: {
+        lexicon: number;
+        id: string;
+        defs: {
+            main: {
+                type: string;
+                description: string;
+                input: {
+                    encoding: string;
+                    schema: {
+                        type: string;
+                        required: string[];
+                        properties: {
+                            email: {
+                                type: string;
+                            };
+                            token: {
+                                type: string;
+                            };
+                        };
+                    };
+                };
+                errors: {
+                    name: string;
+                }[];
+            };
+        };
+    };
     ComAtprotoServerCreateAccount: {
         lexicon: number;
         id: string;
@@ -2321,6 +2349,9 @@ export declare const schemaDict: {
                             email: {
                                 type: string;
                             };
+                            emailConfirmed: {
+                                type: string;
+                            };
                         };
                     };
                 };
@@ -2533,6 +2564,9 @@ export declare const schemaDict: {
                             email: {
                                 type: string;
                             };
+                            emailConfirmed: {
+                                type: string;
+                            };
                         };
                     };
                 };
@@ -2627,6 +2661,38 @@ export declare const schemaDict: {
             };
         };
     };
+    ComAtprotoServerRequestEmailConfirmation: {
+        lexicon: number;
+        id: string;
+        defs: {
+            main: {
+                type: string;
+                description: string;
+            };
+        };
+    };
+    ComAtprotoServerRequestEmailUpdate: {
+        lexicon: number;
+        id: string;
+        defs: {
+            main: {
+                type: string;
+                description: string;
+                output: {
+                    encoding: string;
+                    schema: {
+                        type: string;
+                        required: string[];
+                        properties: {
+                            tokenRequired: {
+                                type: string;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
     ComAtprotoServerRequestPasswordReset: {
         lexicon: number;
         id: string;
@@ -2699,6 +2765,35 @@ export declare const schemaDict: {
             };
         };
     };
+    ComAtprotoServerUpdateEmail: {
+        lexicon: number;
+        id: string;
+        defs: {
+            main: {
+                type: string;
+                description: string;
+                input: {
+                    encoding: string;
+                    schema: {
+                        type: string;
+                        required: string[];
+                        properties: {
+                            email: {
+                                type: string;
+                            };
+                            token: {
+                                type: string;
+                                description: string;
+                            };
+                        };
+                    };
+                };
+                errors: {
+                    name: string;
+                }[];
+            };
+        };
+    };
     ComAtprotoSyncGetBlob: {
         lexicon: number;
         id: string;
@@ -6836,6 +6931,7 @@ export declare const ids: {
     ComAtprotoRepoPutRecord: string;
     ComAtprotoRepoStrongRef: string;
     ComAtprotoRepoUploadBlob: string;
+    ComAtprotoServerConfirmEmail: string;
     ComAtprotoServerCreateAccount: string;
     ComAtprotoServerCreateAppPassword: string;
     ComAtprotoServerCreateInviteCode: string;
@@ -6850,9 +6946,12 @@ export declare const ids: {
     ComAtprotoServerListAppPasswords: string;
     ComAtprotoServerRefreshSession: string;
     ComAtprotoServerRequestAccountDelete: string;
+    ComAtprotoServerRequestEmailConfirmation: string;
+    ComAtprotoServerRequestEmailUpdate: string;
     ComAtprotoServerRequestPasswordReset: string;
     ComAtprotoServerResetPassword: string;
     ComAtprotoServerRevokeAppPassword: string;
+    ComAtprotoServerUpdateEmail: string;
     ComAtprotoSyncGetBlob: string;
     ComAtprotoSyncGetBlocks: string;
     ComAtprotoSyncGetCheckout: string;

package/dist/lexicon/types/com/atproto/server/confirmEmail.d.ts

@@ -0,0 +1,27 @@
+import express from 'express';
+import { HandlerAuth } from '@atproto/xrpc-server';
+export interface QueryParams {
+}
+export interface InputSchema {
+    email: string;
+    token: string;
+    [k: string]: unknown;
+}
+export interface HandlerInput {
+    encoding: 'application/json';
+    body: InputSchema;
+}
+export interface HandlerError {
+    status: number;
+    message?: string;
+    error?: 'AccountNotFound' | 'ExpiredToken' | 'InvalidToken' | 'InvalidEmail';
+}
+export declare type HandlerOutput = HandlerError | void;
+export declare type HandlerReqCtx<HA extends HandlerAuth = never> = {
+    auth: HA;
+    params: QueryParams;
+    input: HandlerInput;
+    req: express.Request;
+    res: express.Response;
+};
+export declare type Handler<HA extends HandlerAuth = never> = (ctx: HandlerReqCtx<HA>) => Promise<HandlerOutput> | HandlerOutput;

package/dist/lexicon/types/com/atproto/server/createSession.d.ts

@@ -13,6 +13,7 @@ export interface OutputSchema {
     handle: string;
     did: string;
     email?: string;
+    emailConfirmed?: boolean;
     [k: string]: unknown;
 }
 export interface HandlerInput {

package/dist/lexicon/types/com/atproto/server/getSession.d.ts

@@ -7,6 +7,7 @@ export interface OutputSchema {
     handle: string;
     did: string;
     email?: string;
+    emailConfirmed?: boolean;
     [k: string]: unknown;
 }
 export declare type HandlerInput = undefined;

package/dist/lexicon/types/com/atproto/server/requestEmailConfirmation.d.ts

@@ -0,0 +1,19 @@
+import express from 'express';
+import { HandlerAuth } from '@atproto/xrpc-server';
+export interface QueryParams {
+}
+export declare type InputSchema = undefined;
+export declare type HandlerInput = undefined;
+export interface HandlerError {
+    status: number;
+    message?: string;
+}
+export declare type HandlerOutput = HandlerError | void;
+export declare type HandlerReqCtx<HA extends HandlerAuth = never> = {
+    auth: HA;
+    params: QueryParams;
+    input: HandlerInput;
+    req: express.Request;
+    res: express.Response;
+};
+export declare type Handler<HA extends HandlerAuth = never> = (ctx: HandlerReqCtx<HA>) => Promise<HandlerOutput> | HandlerOutput;

package/dist/lexicon/types/com/atproto/server/requestEmailUpdate.d.ts

@@ -0,0 +1,30 @@
+import express from 'express';
+import { HandlerAuth } from '@atproto/xrpc-server';
+export interface QueryParams {
+}
+export declare type InputSchema = undefined;
+export interface OutputSchema {
+    tokenRequired: boolean;
+    [k: string]: unknown;
+}
+export declare type HandlerInput = undefined;
+export interface HandlerSuccess {
+    encoding: 'application/json';
+    body: OutputSchema;
+    headers?: {
+        [key: string]: string;
+    };
+}
+export interface HandlerError {
+    status: number;
+    message?: string;
+}
+export declare type HandlerOutput = HandlerError | HandlerSuccess;
+export declare type HandlerReqCtx<HA extends HandlerAuth = never> = {
+    auth: HA;
+    params: QueryParams;
+    input: HandlerInput;
+    req: express.Request;
+    res: express.Response;
+};
+export declare type Handler<HA extends HandlerAuth = never> = (ctx: HandlerReqCtx<HA>) => Promise<HandlerOutput> | HandlerOutput;

package/dist/lexicon/types/com/atproto/server/updateEmail.d.ts

@@ -0,0 +1,27 @@
+import express from 'express';
+import { HandlerAuth } from '@atproto/xrpc-server';
+export interface QueryParams {
+}
+export interface InputSchema {
+    email: string;
+    token?: string;
+    [k: string]: unknown;
+}
+export interface HandlerInput {
+    encoding: 'application/json';
+    body: InputSchema;
+}
+export interface HandlerError {
+    status: number;
+    message?: string;
+    error?: 'ExpiredToken' | 'InvalidToken' | 'TokenRequired';
+}
+export declare type HandlerOutput = HandlerError | void;
+export declare type HandlerReqCtx<HA extends HandlerAuth = never> = {
+    auth: HA;
+    params: QueryParams;
+    input: HandlerInput;
+    req: express.Request;
+    res: express.Response;
+};
+export declare type Handler<HA extends HandlerAuth = never> = (ctx: HandlerReqCtx<HA>) => Promise<HandlerOutput> | HandlerOutput;

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

@@ -15,10 +15,10 @@ export declare class ActorService {
     getActorDid(handleOrDid: string): Promise<string | null>;
     getActor(handleOrDid: string, includeSoftDeleted?: boolean): Promise<ActorResult | null>;
     getActors(handleOrDids: string[], includeSoftDeleted?: boolean): Promise<ActorResult[]>;
-    getSearchResults({ cursor, limit, term, includeSoftDeleted, }: {
+    getSearchResults({ cursor, limit, query, includeSoftDeleted, }: {
         cursor?: string;
         limit?: number;
-        term?: string;
+        query?: string;
         includeSoftDeleted?: boolean;
     }): Promise<{
         results: Actor[];

package/dist/services/util/search.d.ts

@@ -1,7 +1,7 @@
 import { Database } from '../../db';
 import { GenericKeyset } from '../../db/pagination';
 export declare const getUserSearchQuery: (db: Database, opts: {
-    term: string;
+    query: string;
     limit: number;
     cursor?: string;
     includeSoftDeleted?: boolean;
@@ -10,13 +10,13 @@ export declare const getUserSearchQuery: (db: Database, opts: {
     distance: number;
 }, "results">>, "actor" | "results", {}>;
 export declare const getUserSearchQuerySimple: (db: Database, opts: {
-    term: string;
+    query: string;
     limit: number;
 }) => import("kysely").SelectQueryBuilder<import("kysely/dist/cjs/parser/table-parser").From<import("../../db/database-schema").DatabaseSchemaType, import("kysely").AliasedQueryBuilder<import("kysely/dist/cjs/parser/table-parser").From<import("../../db/database-schema").DatabaseSchemaType, import("kysely").AliasedQueryBuilder<import("kysely/dist/cjs/parser/table-parser").From<import("../../db/database-schema").DatabaseSchemaType, "actor">, "actor", import("kysely").Selection<import("kysely/dist/cjs/parser/table-parser").From<import("../../db/database-schema").DatabaseSchemaType, "actor">, "actor", import("kysely").AliasedRawBuilder<number, "distance"> | import("kysely").AliasedRawBuilder<unknown, "did">>, "accounts_and_profiles">>, "accounts_and_profiles", {
     did: unknown;
     distance: number;
 }, "results">>, "actor" | "results", {}>;
-export declare const cleanTerm: (term: string) => string;
+export declare const cleanQuery: (query: string) => string;
 declare type Result = {
     distance: number;
     did: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/bsky",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "license": "MIT",
   "description": "Reference implementation of app.bsky App View (Bluesky API)",
   "keywords": [
@@ -36,14 +36,14 @@
     "sharp": "^0.31.2",
     "typed-emitter": "^2.1.0",
     "uint8arrays": "3.0.0",
-    "@atproto/api": "^0.6.19",
-    "@atproto/common": "^0.3.0",
+    "@atproto/api": "^0.6.20",
+    "@atproto/common": "^0.3.1",
     "@atproto/crypto": "^0.2.2",
-    "@atproto/syntax": "^0.1.1",
-    "@atproto/identity": "^0.2.0",
-    "@atproto/lexicon": "^0.2.1",
-    "@atproto/repo": "^0.3.1",
-    "@atproto/xrpc-server": "^0.3.1"
+    "@atproto/syntax": "^0.1.2",
+    "@atproto/identity": "^0.2.1",
+    "@atproto/lexicon": "^0.2.2",
+    "@atproto/repo": "^0.3.2",
+    "@atproto/xrpc-server": "^0.3.2"
   },
   "devDependencies": {
     "@did-plc/server": "^0.0.1",
@@ -54,11 +54,11 @@
     "@types/qs": "^6.9.7",
     "@types/sharp": "^0.31.0",
     "axios": "^0.27.2",
-    "@atproto/api": "^0.6.19",
-    "@atproto/dev-env": "^0.2.10",
-    "@atproto/lex-cli": "^0.2.1",
-    "@atproto/pds": "^0.1.19",
-    "@atproto/xrpc": "^0.3.1"
+    "@atproto/api": "^0.6.20",
+    "@atproto/dev-env": "^0.2.11",
+    "@atproto/lex-cli": "^0.2.2",
+    "@atproto/pds": "^0.1.20",
+    "@atproto/xrpc": "^0.3.2"
   },
   "scripts": {
     "codegen": "lex gen-server ./src/lexicon ../../lexicons/com/atproto/*/* ../../lexicons/app/bsky/*/*",

package/src/api/app/bsky/actor/searchActors.ts

@@ -2,7 +2,7 @@ import { sql } from 'kysely'
 import AppContext from '../../../../context'
 import { Server } from '../../../../lexicon'
 import {
-  cleanTerm,
+  cleanQuery,
   getUserSearchQuery,
   SearchKeyset,
 } from '../../../../services/util/search'
@@ -11,37 +11,51 @@ export default function (server: Server, ctx: AppContext) {
   server.app.bsky.actor.searchActors({
     auth: ctx.authOptionalVerifier,
     handler: async ({ auth, params }) => {
-      let { cursor, limit, term: rawTerm, q: rawQ } = params
+      const { cursor, limit } = params
       const requester = auth.credentials.did
-
-      // prefer new 'q' query param over deprecated 'term'
-      if (rawQ) {
-        rawTerm = rawQ
-      }
-
-      const term = cleanTerm(rawTerm || '')
-
+      const rawQuery = params.q ?? params.term
+      const query = cleanQuery(rawQuery || '')
       const db = ctx.db.getReplica('search')
 
-      const results = term
-        ? await getUserSearchQuery(db, { term, limit, cursor })
-            .select('distance')
-            .selectAll('actor')
-            .execute()
-        : []
-      const keyset = new SearchKeyset(sql``, sql``)
+      let results: string[]
+      let resCursor: string | undefined
+      if (ctx.searchAgent) {
+        const res =
+          await ctx.searchAgent.api.app.bsky.unspecced.searchActorsSkeleton({
+            q: query,
+            cursor,
+            limit,
+          })
+        results = res.data.actors.map((a) => a.did)
+        resCursor = res.data.cursor
+      } else {
+        const res = query
+          ? await getUserSearchQuery(db, { query, limit, cursor })
+              .select('distance')
+              .selectAll('actor')
+              .execute()
+          : []
+        results = res.map((a) => a.did)
+        const keyset = new SearchKeyset(sql``, sql``)
+        resCursor = keyset.packFromResult(res)
+      }
 
       const actors = await ctx.services
         .actor(db)
-        .views.profilesList(results, requester)
-      const filtered = actors.filter(
-        (actor) => !actor.viewer?.blocking && !actor.viewer?.blockedBy,
-      )
+        .views.profiles(results, requester)
+
+      const SKIP = []
+      const filtered = results.flatMap((did) => {
+        const actor = actors[did]
+        if (!actor) return SKIP
+        if (actor.viewer?.blocking || actor.viewer?.blockedBy) return SKIP
+        return actor
+      })
 
       return {
         encoding: 'application/json',
         body: {
-          cursor: keyset.packFromResult(results),
+          cursor: resCursor,
           actors: filtered,
         },
       }

package/src/api/app/bsky/actor/searchActorsTypeahead.ts

@@ -1,7 +1,7 @@
 import AppContext from '../../../../context'
 import { Server } from '../../../../lexicon'
 import {
-  cleanTerm,
+  cleanQuery,
   getUserSearchQuerySimple,
 } from '../../../../services/util/search'
 
@@ -9,31 +9,38 @@ export default function (server: Server, ctx: AppContext) {
   server.app.bsky.actor.searchActorsTypeahead({
     auth: ctx.authOptionalVerifier,
     handler: async ({ params, auth }) => {
-      let { limit, term: rawTerm, q: rawQ } = params
+      const { limit } = params
       const requester = auth.credentials.did
-
-      // prefer new 'q' query param over deprecated 'term'
-      if (rawQ) {
-        rawTerm = rawQ
-      }
-
-      const term = cleanTerm(rawTerm || '')
-
+      const rawQuery = params.q ?? params.term
+      const query = cleanQuery(rawQuery || '')
       const db = ctx.db.getReplica('search')
 
-      const results = term
-        ? await getUserSearchQuerySimple(db, { term, limit })
-            .selectAll('actor')
-            .execute()
-        : []
+      let results: string[]
+      if (ctx.searchAgent) {
+        const res =
+          await ctx.searchAgent.api.app.bsky.unspecced.searchActorsSkeleton({
+            q: query,
+            typeahead: true,
+            limit,
+          })
+        results = res.data.actors.map((a) => a.did)
+      } else {
+        const res = query
+          ? await getUserSearchQuerySimple(db, { query, limit })
+              .selectAll('actor')
+              .execute()
+          : []
+        results = res.map((a) => a.did)
+      }
 
       const actors = await ctx.services
         .actor(db)
         .views.profilesBasic(results, requester, { omitLabels: true })
 
       const SKIP = []
-      const filtered = results.flatMap((res) => {
-        const actor = actors[res.did]
+      const filtered = results.flatMap((did) => {
+        const actor = actors[did]
+        if (!actor) return SKIP
         if (actor.viewer?.blocking || actor.viewer?.blockedBy) return SKIP
         return actor
       })

package/src/api/app/bsky/graph/getSuggestedFollowsByActor.ts

@@ -78,6 +78,7 @@ async function getSkeleton(
         .selectFrom('like')
         .where('creator', '=', params.actor)
         .select(sql`split_part(subject, '/', 3)`.as('subjectDid'))
+        .orderBy('sortAt', 'desc')
         .limit(1000) // limit to 1000
         .as('likes'),
     )

package/src/api/com/atproto/admin/searchRepos.ts

@@ -8,23 +8,20 @@ export default function (server: Server, ctx: AppContext) {
     handler: async ({ params }) => {
       const db = ctx.db.getPrimary()
       const moderationService = ctx.services.moderation(db)
-      const { invitedBy } = params
+      const { invitedBy, limit, cursor } = params
       if (invitedBy) {
         throw new InvalidRequestError('The invitedBy parameter is unsupported')
       }
       // prefer new 'q' query param over deprecated 'term'
-      const { q } = params
-      if (q) {
-        params.term = q
-      }
+      const query = params.q ?? params.term
 
-      const { results, cursor } = await ctx.services
+      const { results, cursor: resCursor } = await ctx.services
         .actor(db)
-        .getSearchResults({ ...params, includeSoftDeleted: true })
+        .getSearchResults({ query, limit, cursor, includeSoftDeleted: true })
       return {
         encoding: 'application/json',
         body: {
-          cursor,
+          cursor: resCursor,
           repos: await moderationService.views.repo(results),
         },
       }

package/src/config.ts

@@ -18,6 +18,7 @@ export interface ServerConfigValues {
   handleResolveNameservers?: string[]
   imgUriEndpoint?: string
   blobCacheLocation?: string
+  searchEndpoint?: string
   labelerDid: string
   adminPassword: string
   moderatorPassword?: string
@@ -51,6 +52,7 @@ export class ServerConfig {
       : []
     const imgUriEndpoint = process.env.IMG_URI_ENDPOINT
     const blobCacheLocation = process.env.BLOB_CACHE_LOC
+    const searchEndpoint = process.env.SEARCH_ENDPOINT
     const dbPrimaryPostgresUrl =
       overrides?.dbPrimaryPostgresUrl || process.env.DB_PRIMARY_POSTGRES_URL
     let dbReplicaPostgresUrls = overrides?.dbReplicaPostgresUrls
@@ -97,6 +99,7 @@ export class ServerConfig {
       handleResolveNameservers,
       imgUriEndpoint,
       blobCacheLocation,
+      searchEndpoint,
       labelerDid,
       adminPassword,
       moderatorPassword,
@@ -183,6 +186,10 @@ export class ServerConfig {
     return this.cfg.blobCacheLocation
   }
 
+  get searchEndpoint() {
+    return this.cfg.searchEndpoint
+  }
+
   get labelerDid() {
     return this.cfg.labelerDid
   }

package/src/context.ts

@@ -10,6 +10,7 @@ import { BackgroundQueue } from './background'
 import { MountedAlgos } from './feed-gen/types'
 import { LabelCache } from './label-cache'
 import { NotificationServer } from './notifications'
+import { AtpAgent } from '@atproto/api'
 
 export class AppContext {
   constructor(
@@ -22,6 +23,7 @@ export class AppContext {
       didCache: DidSqlCache
       labelCache: LabelCache
       backgroundQueue: BackgroundQueue
+      searchAgent?: AtpAgent
       algos: MountedAlgos
       notifServer: NotificationServer
     },
@@ -63,6 +65,10 @@ export class AppContext {
     return this.opts.notifServer
   }
 
+  get searchAgent(): AtpAgent | undefined {
+    return this.opts.searchAgent
+  }
+
   get authVerifier() {
     return auth.authVerifier(this.idResolver, { aud: this.cfg.serverDid })
   }