fix(suggestions): use PDS-native listRecords for follow import (#112)

The Bluesky follow import was silently failing because it used
agent.getFollows() (an AppView endpoint) through the authenticated
PDS agent. Switch to com.atproto.repo.listRecords which reads
app.bsky.graph.follow records directly from the user's PDS —
works with any PDS, no Bluesky AppView dependency.

Also adds POST /api/suggestions/sync endpoint so existing users
can trigger a re-import without logging out and back in.

src/oauth/routes.ts

···
 import { Agent } from '@atproto/api';
 import type { Database } from '../db/index.js';
 import { sessions, profiles, oauthSessions } from '../db/schema/index.js';
-import { importBlueskyFollows } from '../services/bluesky-follows.js';
-import { importTangledFollows } from '../services/tangled-follows.js';
+import { fetchBlueskyFollowsFromPds, importBlueskyFollows } from '../services/bluesky-follows.js';
+import { fetchTangledFollowsFromPds, importTangledFollows } from '../services/tangled-follows.js';
 
 const loginSchema = z.object({
   handle: z.string().min(1).max(253),
···
       }
 
       // Import follows from Bluesky and Tangled (fire-and-forget, non-blocking)
+      // Uses PDS-native listRecords — works with any PDS, no AppView dependency.
       void (async () => {
         try {
           const agent = new Agent(session);
 
-          // Import Bluesky follows
-          const bskyFollows: Array<{ did: string; handle: string; createdAt: string }> = [];
-          let cursor: string | undefined;
-          do {
-            const res = await agent.getFollows({ actor: did, limit: 100, cursor });
-            for (const f of res.data.follows) {
-              bskyFollows.push({
-                did: f.did,
-                handle: f.handle,
-                createdAt: f.indexedAt ?? new Date().toISOString(),
-              });
-            }
-            cursor = res.data.cursor;
-          } while (cursor);
+          // Import Bluesky follows from PDS
+          const bskyFollows = await fetchBlueskyFollowsFromPds(agent, did);
           await importBlueskyFollows(db, did, bskyFollows);
           app.log.info({ did, count: bskyFollows.length }, 'Imported Bluesky follows');
 
-          // Import Tangled follows (read from user's PDS repo)
+          // Import Tangled follows from PDS
           try {
-            const tangledFollows: Array<{ did: string; handle: string; createdAt: string }> = [];
-            let tangledCursor: string | undefined;
-            do {
-              const res = await agent.com.atproto.repo.listRecords({
-                repo: did,
-                collection: 'sh.tangled.graph.follow',
-                limit: 100,
-                cursor: tangledCursor,
-              });
-              for (const record of res.data.records) {
-                const val = record.value as { subject?: string; createdAt?: string };
-                if (val.subject) {
-                  tangledFollows.push({
-                    did: val.subject,
-                    handle: '', // We don't have the handle from PDS records
-                    createdAt: val.createdAt ?? new Date().toISOString(),
-                  });
-                }
-              }
-              tangledCursor = res.data.cursor;
-            } while (tangledCursor);
+            const tangledFollows = await fetchTangledFollowsFromPds(agent, did);
             await importTangledFollows(db, did, tangledFollows);
             app.log.info({ did, count: tangledFollows.length }, 'Imported Tangled follows');
           } catch (err) {

src/routes/suggestions.ts

···
 import type { FastifyInstance } from 'fastify';
 import { z } from 'zod';
+import { Agent } from '@atproto/api';
 import type { NodeOAuthClient } from '@atproto/oauth-client-node';
 import type { Database } from '../db/index.js';
 import { connections, profiles, suggestionDismissals, invites } from '../db/schema/index.js';
 import { and, eq, ne, notInArray, sql, count, gt } from 'drizzle-orm';
 import { createAuthMiddleware, getAuthContext } from '../middleware/auth.js';
+import { fetchBlueskyFollowsFromPds, importBlueskyFollows } from '../services/bluesky-follows.js';
+import { fetchTangledFollowsFromPds, importTangledFollows } from '../services/tangled-follows.js';
 
 const dismissSchema = z.object({
   subjectDid: z.string().startsWith('did:'),
···
         );
 
       return reply.status(200).send({ status: 'ok' });
+    },
+  );
+
+  // POST /api/suggestions/sync -- re-import follows from PDS
+  app.post(
+    '/api/suggestions/sync',
+    { preHandler: requireAuth, config: { rateLimit: { max: 3, timeWindow: '1 minute' } } },
+    async (request, reply) => {
+      const { did, session } = getAuthContext(request);
+      const agent = new Agent(session);
+
+      let blueskyCount = 0;
+      let tangledCount = 0;
+
+      // Import Bluesky follows
+      try {
+        const bskyFollows = await fetchBlueskyFollowsFromPds(agent, did);
+        await importBlueskyFollows(db, did, bskyFollows);
+        blueskyCount = bskyFollows.length;
+        app.log.info({ did, count: blueskyCount }, 'Synced Bluesky follows');
+      } catch (err) {
+        app.log.error({ err, did }, 'Bluesky follow sync failed');
+      }
+
+      // Import Tangled follows
+      try {
+        const tangledFollows = await fetchTangledFollowsFromPds(agent, did);
+        await importTangledFollows(db, did, tangledFollows);
+        tangledCount = tangledFollows.length;
+        app.log.info({ did, count: tangledCount }, 'Synced Tangled follows');
+      } catch (err) {
+        app.log.debug({ err, did }, 'Tangled follow sync skipped or failed');
+      }
+
+      return reply.send({
+        status: 'ok',
+        imported: { bluesky: blueskyCount, tangled: tangledCount },
+      });
     },
   );
 

src/services/bluesky-follows.ts

···
+import type { Agent } from '@atproto/api';
 import type { Database } from '../db/index.js';
 import { connections } from '../db/schema/index.js';
 
-export function mapBskyFollowToConnection(
-  followerDid: string,
-  follow: { did: string; handle: string; createdAt: string },
-) {
-  return {
-    followerDid,
-    subjectDid: follow.did,
-    source: 'bluesky' as const,
-    createdAt: new Date(follow.createdAt),
-  };
+/**
+ * Fetches Bluesky follows from the user's PDS using listRecords
+ * (AT Protocol-native, works with any PDS — no Bluesky AppView dependency).
+ */
+export async function fetchBlueskyFollowsFromPds(
+  agent: Agent,
+  did: string,
+): Promise<Array<{ did: string; createdAt: string }>> {
+  const follows: Array<{ did: string; createdAt: string }> = [];
+  let cursor: string | undefined;
+  do {
+    const res = await agent.com.atproto.repo.listRecords({
+      repo: did,
+      collection: 'app.bsky.graph.follow',
+      limit: 100,
+      cursor,
+    });
+    for (const record of res.data.records) {
+      const val = record.value as { subject?: string; createdAt?: string };
+      if (val.subject) {
+        follows.push({
+          did: val.subject,
+          createdAt: val.createdAt ?? new Date().toISOString(),
+        });
+      }
+    }
+    cursor = res.data.cursor;
+  } while (cursor);
+  return follows;
 }
 
 export async function importBlueskyFollows(
   db: Database,
   followerDid: string,
-  follows: Array<{ did: string; handle: string; createdAt: string }>,
+  follows: Array<{ did: string; createdAt: string }>,
 ) {
-  const rows = follows.map((f) => mapBskyFollowToConnection(followerDid, f));
+  const rows = follows.map((f) => ({
+    followerDid,
+    subjectDid: f.did,
+    source: 'bluesky' as const,
+    createdAt: new Date(f.createdAt),
+  }));
   if (rows.length === 0) return;
 
   await db.insert(connections).values(rows).onConflictDoNothing();

src/services/tangled-follows.ts

···
+import type { Agent } from '@atproto/api';
 import type { Database } from '../db/index.js';
 import { connections } from '../db/schema/index.js';
 
-export function mapTangledFollowToConnection(
-  followerDid: string,
-  follow: { did: string; handle: string; createdAt: string },
-) {
-  return {
-    followerDid,
-    subjectDid: follow.did,
-    source: 'tangled' as const,
-    createdAt: new Date(follow.createdAt),
-  };
+/**
+ * Fetches Tangled follows from the user's PDS using listRecords.
+ */
+export async function fetchTangledFollowsFromPds(
+  agent: Agent,
+  did: string,
+): Promise<Array<{ did: string; createdAt: string }>> {
+  const follows: Array<{ did: string; createdAt: string }> = [];
+  let cursor: string | undefined;
+  do {
+    const res = await agent.com.atproto.repo.listRecords({
+      repo: did,
+      collection: 'sh.tangled.graph.follow',
+      limit: 100,
+      cursor,
+    });
+    for (const record of res.data.records) {
+      const val = record.value as { subject?: string; createdAt?: string };
+      if (val.subject) {
+        follows.push({
+          did: val.subject,
+          createdAt: val.createdAt ?? new Date().toISOString(),
+        });
+      }
+    }
+    cursor = res.data.cursor;
+  } while (cursor);
+  return follows;
 }
 
 export async function importTangledFollows(
   db: Database,
   followerDid: string,
-  follows: Array<{ did: string; handle: string; createdAt: string }>,
+  follows: Array<{ did: string; createdAt: string }>,
 ) {
-  const rows = follows.map((f) => mapTangledFollowToConnection(followerDid, f));
+  const rows = follows.map((f) => ({
+    followerDid,
+    subjectDid: f.did,
+    source: 'tangled' as const,
+    createdAt: new Date(f.createdAt),
+  }));
   if (rows.length === 0) return;
 
   await db.insert(connections).values(rows).onConflictDoNothing();

tests/services/bluesky-follows.test.ts

···
-import { describe, it, expect } from 'vitest';
-import { mapBskyFollowToConnection } from '../../src/services/bluesky-follows.js';
+import { describe, it, expect, vi } from 'vitest';
 
-describe('Bluesky follow import', () => {
-  it('maps Bluesky follow to connection row', () => {
-    const conn = mapBskyFollowToConnection('did:plc:follower', {
-      did: 'did:plc:subject',
-      handle: 'alice.bsky.social',
-      createdAt: '2026-01-01T00:00:00Z',
-    });
-    expect(conn.source).toBe('bluesky');
-    expect(conn.followerDid).toBe('did:plc:follower');
-    expect(conn.subjectDid).toBe('did:plc:subject');
+// Mock drizzle to capture insert values
+const insertedValues: unknown[] = [];
+vi.mock('../../src/db/schema/index.js', () => ({
+  connections: 'connections_table',
+}));
+
+vi.mock('drizzle-orm/pg-core', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('drizzle-orm/pg-core')>();
+  return actual;
+});
+
+const mockDb = {
+  insert: vi.fn().mockReturnValue({
+    values: vi.fn().mockImplementation((rows: unknown[]) => {
+      insertedValues.push(...rows);
+      return { onConflictDoNothing: vi.fn() };
+    }),
+  }),
+};
+
+// Must import after mocks
+const { importBlueskyFollows } = await import('../../src/services/bluesky-follows.js');
+
+describe('importBlueskyFollows', () => {
+  it('maps follows to connection rows with source bluesky', async () => {
+    insertedValues.length = 0;
+    await importBlueskyFollows(mockDb as never, 'did:plc:follower', [
+      { did: 'did:plc:subject', createdAt: '2026-01-01T00:00:00Z' },
+    ]);
+
+    expect(insertedValues).toHaveLength(1);
+    const row = insertedValues[0] as Record<string, unknown>;
+    expect(row.source).toBe('bluesky');
+    expect(row.followerDid).toBe('did:plc:follower');
+    expect(row.subjectDid).toBe('did:plc:subject');
+    expect(row.createdAt).toBeInstanceOf(Date);
+    expect((row.createdAt as Date).toISOString()).toBe('2026-01-01T00:00:00.000Z');
   });
 
-  it('sets createdAt as Date from ISO string', () => {
-    const conn = mapBskyFollowToConnection('did:plc:follower', {
-      did: 'did:plc:subject',
-      handle: 'alice.bsky.social',
-      createdAt: '2026-01-01T00:00:00Z',
-    });
-    expect(conn.createdAt).toBeInstanceOf(Date);
-    expect(conn.createdAt.toISOString()).toBe('2026-01-01T00:00:00.000Z');
+  it('skips insert when follows array is empty', async () => {
+    mockDb.insert.mockClear();
+    await importBlueskyFollows(mockDb as never, 'did:plc:follower', []);
+    expect(mockDb.insert).not.toHaveBeenCalled();
   });
 });

tests/services/tangled-follows.test.ts

···
-import { describe, it, expect } from 'vitest';
-import { mapTangledFollowToConnection } from '../../src/services/tangled-follows.js';
+import { describe, it, expect, vi } from 'vitest';
 
-describe('Tangled follow import', () => {
-  it('maps Tangled follow to connection row with source tangled', () => {
-    const conn = mapTangledFollowToConnection('did:plc:follower', {
-      did: 'did:plc:subject',
-      handle: 'alice.tangled.sh',
-      createdAt: '2026-01-15T12:00:00Z',
-    });
-    expect(conn.source).toBe('tangled');
-    expect(conn.followerDid).toBe('did:plc:follower');
-    expect(conn.subjectDid).toBe('did:plc:subject');
+const insertedValues: unknown[] = [];
+vi.mock('../../src/db/schema/index.js', () => ({
+  connections: 'connections_table',
+}));
+
+const mockDb = {
+  insert: vi.fn().mockReturnValue({
+    values: vi.fn().mockImplementation((rows: unknown[]) => {
+      insertedValues.push(...rows);
+      return { onConflictDoNothing: vi.fn() };
+    }),
+  }),
+};
+
+const { importTangledFollows } = await import('../../src/services/tangled-follows.js');
+
+describe('importTangledFollows', () => {
+  it('maps follows to connection rows with source tangled', async () => {
+    insertedValues.length = 0;
+    await importTangledFollows(mockDb as never, 'did:plc:follower', [
+      { did: 'did:plc:subject', createdAt: '2026-01-15T12:00:00Z' },
+    ]);
+
+    expect(insertedValues).toHaveLength(1);
+    const row = insertedValues[0] as Record<string, unknown>;
+    expect(row.source).toBe('tangled');
+    expect(row.followerDid).toBe('did:plc:follower');
+    expect(row.subjectDid).toBe('did:plc:subject');
+    expect(row.createdAt).toBeInstanceOf(Date);
+    expect((row.createdAt as Date).toISOString()).toBe('2026-01-15T12:00:00.000Z');
   });
 
-  it('sets createdAt as Date from ISO string', () => {
-    const conn = mapTangledFollowToConnection('did:plc:follower', {
-      did: 'did:plc:subject',
-      handle: 'bob.tangled.sh',
-      createdAt: '2026-02-01T00:00:00Z',
-    });
-    expect(conn.createdAt).toBeInstanceOf(Date);
-    expect(conn.createdAt.toISOString()).toBe('2026-02-01T00:00:00.000Z');
+  it('skips insert when follows array is empty', async () => {
+    mockDb.insert.mockClear();
+    await importTangledFollows(mockDb as never, 'did:plc:follower', []);
+    expect(mockDb.insert).not.toHaveBeenCalled();
   });
 });