Merge pull request #123 from singi-labs/feat/cross-app-activity

feat: cross-app activity API

drizzle/0019_user_app_stats.sql

···
+CREATE TABLE IF NOT EXISTS "user_app_stats" (
+  "did" text NOT NULL REFERENCES "profiles"("did") ON DELETE CASCADE,
+  "app_id" text NOT NULL,
+  "is_active" boolean NOT NULL DEFAULT false,
+  "recent_count" integer NOT NULL DEFAULT 0,
+  "latest_record_at" timestamptz,
+  "refreshed_at" timestamptz NOT NULL DEFAULT now(),
+  "visible" boolean NOT NULL DEFAULT true,
+  "created_at" timestamptz NOT NULL DEFAULT now(),
+  PRIMARY KEY ("did", "app_id")
+);
+
+CREATE INDEX IF NOT EXISTS "idx_user_app_stats_app_count" ON "user_app_stats" ("app_id", "recent_count");
+CREATE INDEX IF NOT EXISTS "idx_user_app_stats_refreshed" ON "user_app_stats" ("refreshed_at");
+CREATE INDEX IF NOT EXISTS "idx_user_app_stats_visible" ON "user_app_stats" ("did", "visible", "recent_count");
+
+CREATE TABLE IF NOT EXISTS "suppressed_dids" (
+  "did" text PRIMARY KEY,
+  "requested_at" timestamptz NOT NULL DEFAULT now()
+);

drizzle/meta/_journal.json

···
       "when": 1774317600000,
       "tag": "0018_avatar_displayname_overrides",
       "breakpoints": true
+    },
+    {
+      "idx": 19,
+      "version": "7",
+      "when": 1774404000000,
+      "tag": "0019_user_app_stats",
+      "breakpoints": true
     }
   ]
 }

src/db/schema/index.ts

···
 export { skillPositionLinks } from './skill-position-links.js';
 export { linkedinImports } from './linkedin-imports.js';
 export { featuredProfiles } from './featured-profiles.js';
+export { userAppStats } from './user-app-stats.js';
+export { suppressedDids } from './suppressed-dids.js';

src/db/schema/suppressed-dids.ts

···
+import { pgTable, text, timestamp } from 'drizzle-orm/pg-core';
+
+export const suppressedDids = pgTable('suppressed_dids', {
+  did: text('did').primaryKey(),
+  requestedAt: timestamp('requested_at', { withTimezone: true }).notNull().defaultNow(),
+});

src/db/schema/user-app-stats.ts

···
+import { pgTable, text, timestamp, boolean, integer, primaryKey, index } from 'drizzle-orm/pg-core';
+import { profiles } from './profiles.js';
+
+export const userAppStats = pgTable(
+  'user_app_stats',
+  {
+    did: text('did')
+      .notNull()
+      .references(() => profiles.did, { onDelete: 'cascade' }),
+    appId: text('app_id').notNull(),
+    isActive: boolean('is_active').notNull().default(false),
+    recentCount: integer('recent_count').notNull().default(0),
+    latestRecordAt: timestamp('latest_record_at', { withTimezone: true }),
+    refreshedAt: timestamp('refreshed_at', { withTimezone: true }).notNull().defaultNow(),
+    visible: boolean('visible').notNull().default(true),
+    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  },
+  (table) => [
+    primaryKey({ columns: [table.did, table.appId] }),
+    index('idx_user_app_stats_app_count').on(table.appId, table.recentCount),
+    index('idx_user_app_stats_refreshed').on(table.refreshedAt),
+    index('idx_user_app_stats_visible').on(table.did, table.visible, table.recentCount),
+  ],
+);

src/lib/atproto-app-registry.ts

···
+export interface AppRegistryEntry {
+  id: string;
+  name: string;
+  category: string;
+  collectionPrefixes: string[];
+  scanCollections: string[];
+  urlPattern?: string;
+  color: string;
+}
+
+const APP_REGISTRY: AppRegistryEntry[] = [
+  {
+    id: 'bluesky',
+    name: 'Bluesky',
+    category: 'Posts',
+    collectionPrefixes: ['app.bsky.feed'],
+    scanCollections: ['app.bsky.feed.post'],
+    urlPattern: 'https://bsky.app/profile/{handle}/post/{rkey}',
+    color: 'sky',
+  },
+  {
+    id: 'tangled',
+    name: 'Tangled',
+    category: 'Code',
+    collectionPrefixes: ['sh.tangled'],
+    scanCollections: [],
+    color: 'emerald',
+  },
+  {
+    id: 'smokesignal',
+    name: 'Smoke Signal',
+    category: 'Events',
+    collectionPrefixes: ['events.smokesignal'],
+    scanCollections: [],
+    color: 'orange',
+  },
+  {
+    id: 'flashes',
+    name: 'Flashes',
+    category: 'Photos',
+    collectionPrefixes: ['blue.flashes'],
+    scanCollections: [],
+    color: 'pink',
+  },
+  {
+    id: 'whitewind',
+    name: 'Whitewind',
+    category: 'Articles',
+    collectionPrefixes: ['com.whtwnd'],
+    scanCollections: ['com.whtwnd.blog.entry'],
+    urlPattern: 'https://whtwnd.com/{handle}/{rkey}',
+    color: 'slate',
+  },
+  {
+    id: 'frontpage',
+    name: 'Frontpage',
+    category: 'Links',
+    collectionPrefixes: ['com.frontpage'],
+    scanCollections: [],
+    color: 'violet',
+  },
+  {
+    id: 'picosky',
+    name: 'Picosky',
+    category: 'Pages',
+    collectionPrefixes: ['blue.picosky'],
+    scanCollections: [],
+    color: 'pink',
+  },
+  {
+    id: 'linkat',
+    name: 'Linkat',
+    category: 'Links',
+    collectionPrefixes: ['blue.linkat'],
+    scanCollections: [],
+    color: 'emerald',
+  },
+  {
+    id: 'pastesphere',
+    name: 'PasteSphere',
+    category: 'Pastes',
+    collectionPrefixes: ['com.pastesphere'],
+    scanCollections: [],
+    color: 'amber',
+  },
+];
+
+export const EXCLUDED_COLLECTIONS: string[] = [
+  'app.bsky.feed.like',
+  'app.bsky.feed.repost',
+  'app.bsky.graph.follow',
+  'app.bsky.graph.block',
+  'app.bsky.graph.mute',
+  'app.bsky.graph.listitem',
+];
+
+export function getAppsRegistry(): AppRegistryEntry[] {
+  return APP_REGISTRY;
+}
+
+export function getAppForCollection(
+  collection: string,
+): (AppRegistryEntry & { matchedPrefix: string }) | undefined {
+  // Exact match on scanCollections first
+  for (const entry of APP_REGISTRY) {
+    if (entry.scanCollections.includes(collection)) {
+      const matchedPrefix: string =
+        entry.collectionPrefixes.find((p) => collection.startsWith(p)) ??
+        entry.collectionPrefixes[0] ??
+        collection;
+      return { ...entry, matchedPrefix };
+    }
+  }
+
+  // Prefix match on collectionPrefixes
+  for (const entry of APP_REGISTRY) {
+    for (const prefix of entry.collectionPrefixes) {
+      if (collection.startsWith(prefix)) {
+        return { ...entry, matchedPrefix: prefix };
+      }
+    }
+  }
+
+  return undefined;
+}

src/routes/activity.ts

···
+import type { FastifyInstance } from 'fastify';
+import type { NodeOAuthClient } from '@atproto/oauth-client-node';
+import { Agent } from '@atproto/api';
+import { z } from 'zod';
+import { eq, and } from 'drizzle-orm';
+import type { Database } from '../db/index.js';
+import type { ValkeyClient } from '../cache/index.js';
+import { userAppStats } from '../db/schema/user-app-stats.js';
+import { profiles } from '../db/schema/index.js';
+import { createAuthMiddleware, getAuthContext } from '../middleware/auth.js';
+import { getVisibleAppStats, isDidSuppressed, suppressDid } from '../services/app-stats.js';
+import { getAppsRegistry, type AppRegistryEntry } from '../lib/atproto-app-registry.js';
+import { resolvePdsHost } from '../lib/pds-provider.js';
+
+const publicBskyAgent = new Agent('https://public.api.bsky.app');
+
+const visibilitySchema = z.object({
+  appId: z.string().min(1).max(200),
+  visible: z.boolean(),
+});
+
+const suppressSchema = z.object({
+  handleOrDid: z.string().min(1).max(500),
+});
+
+interface ActivityItem {
+  uri: string;
+  collection: string;
+  rkey: string;
+  record: unknown;
+  appId: string;
+  appName: string;
+  category: string;
+  indexedAt: string;
+}
+
+interface CompositeCursor {
+  cursors: Record<string, string>;
+}
+
+/**
+ * Resolve a handle-or-DID string to a DID.
+ * Checks the local profiles table first, then falls back to Bluesky public API.
+ */
+async function resolveHandleOrDid(db: Database, handleOrDid: string): Promise<string | null> {
+  const isDid = handleOrDid.startsWith('did:');
+  const normalized = isDid ? handleOrDid : handleOrDid.toLowerCase();
+  const condition = isDid ? eq(profiles.did, normalized) : eq(profiles.handle, normalized);
+
+  const [profile] = await db.select().from(profiles).where(condition).limit(1);
+  if (profile) return profile.did;
+
+  // Fall back to Bluesky public API resolution
+  try {
+    const res = await publicBskyAgent.resolveHandle(
+      { handle: normalized },
+      { signal: AbortSignal.timeout(3000) },
+    );
+    return res.data.did;
+  } catch {
+    return isDid ? normalized : null;
+  }
+}
+
+/**
+ * Determine which collection to fetch for a given registry entry.
+ */
+function getCollectionForApp(entry: AppRegistryEntry): string {
+  if (entry.scanCollections.length > 0) {
+    return entry.scanCollections[0] ?? entry.collectionPrefixes[0] ?? '';
+  }
+  return entry.collectionPrefixes[0] ?? '';
+}
+
+/**
+ * Extract createdAt from a record, falling back to current time.
+ */
+function extractCreatedAt(record: unknown): string {
+  if (
+    record !== null &&
+    typeof record === 'object' &&
+    'createdAt' in record &&
+    typeof (record as Record<string, unknown>).createdAt === 'string'
+  ) {
+    return (record as Record<string, unknown>).createdAt as string;
+  }
+  return new Date().toISOString();
+}
+
+/**
+ * Extract rkey from an AT URI (at://did/collection/rkey).
+ */
+function extractRkey(uri: string): string {
+  const parts = uri.split('/');
+  return parts[parts.length - 1] ?? '';
+}
+
+/**
+ * Fetch recent items from Bluesky via the public AppView API.
+ */
+async function fetchBlueskyItems(did: string, limit: number): Promise<ActivityItem[]> {
+  const res = await publicBskyAgent.app.bsky.feed.getAuthorFeed(
+    { actor: did, limit },
+    { signal: AbortSignal.timeout(3000) },
+  );
+
+  return res.data.feed
+    .filter((item) => item.post.author.did === did) // exclude reposts from others
+    .map((item) => ({
+      uri: item.post.uri,
+      collection: 'app.bsky.feed.post',
+      rkey: extractRkey(item.post.uri),
+      record: item.post.record,
+      appId: 'bluesky',
+      appName: 'Bluesky',
+      category: 'Posts',
+      indexedAt: item.post.indexedAt,
+    }));
+}
+
+/**
+ * Fetch recent items from a PDS via listRecords.
+ */
+async function fetchPdsItems(
+  pdsHost: string,
+  did: string,
+  collection: string,
+  entry: AppRegistryEntry,
+  limit: number,
+  cursor?: string,
+): Promise<{ items: ActivityItem[]; cursor: string | undefined }> {
+  const agent = new Agent(`https://${pdsHost}`);
+  const params: Record<string, unknown> = {
+    repo: did,
+    collection,
+    limit,
+  };
+  if (cursor) {
+    params.cursor = cursor;
+  }
+
+  const res = await agent.com.atproto.repo.listRecords(
+    params as { repo: string; collection: string; limit: number; cursor?: string },
+    { signal: AbortSignal.timeout(3000) },
+  );
+
+  const items: ActivityItem[] = res.data.records.map((rec) => ({
+    uri: rec.uri,
+    collection,
+    rkey: extractRkey(rec.uri),
+    record: rec.value,
+    appId: entry.id,
+    appName: entry.name,
+    category: entry.category,
+    indexedAt: extractCreatedAt(rec.value),
+  }));
+
+  return { items, cursor: res.data.cursor };
+}
+
+/**
+ * Fetch Bluesky feed with cursor support for paginated endpoint.
+ */
+async function fetchBlueskyFeedPaginated(
+  did: string,
+  limit: number,
+  cursor?: string,
+): Promise<{ items: ActivityItem[]; cursor: string | undefined }> {
+  const params: { actor: string; limit: number; cursor?: string } = { actor: did, limit };
+  if (cursor) {
+    params.cursor = cursor;
+  }
+
+  const res = await publicBskyAgent.app.bsky.feed.getAuthorFeed(params, {
+    signal: AbortSignal.timeout(3000),
+  });
+
+  const items: ActivityItem[] = res.data.feed
+    .filter((item) => item.post.author.did === did)
+    .map((item) => ({
+      uri: item.post.uri,
+      collection: 'app.bsky.feed.post',
+      rkey: extractRkey(item.post.uri),
+      record: item.post.record,
+      appId: 'bluesky',
+      appName: 'Bluesky',
+      category: 'Posts',
+      indexedAt: item.post.indexedAt,
+    }));
+
+  return { items, cursor: res.data.cursor };
+}
+
+export function registerActivityRoutes(
+  app: FastifyInstance,
+  db: Database,
+  oauthClient: NodeOAuthClient | null,
+  valkey: ValkeyClient | null = null,
+) {
+  const requireAuth = createAuthMiddleware(oauthClient, db);
+
+  // PUT /api/profile/activity-visibility -- toggle visibility of a specific app's activity
+  app.put(
+    '/api/profile/activity-visibility',
+    { preHandler: requireAuth },
+    async (request, reply) => {
+      const parsed = visibilitySchema.safeParse(request.body);
+      if (!parsed.success) {
+        return reply.status(400).send({ error: 'ValidationError', issues: parsed.error.issues });
+      }
+
+      const { did } = getAuthContext(request);
+      const { appId, visible } = parsed.data;
+
+      const result = await db
+        .update(userAppStats)
+        .set({ visible })
+        .where(and(eq(userAppStats.did, did), eq(userAppStats.appId, appId)));
+
+      if (result.rowCount === 0) {
+        return reply.status(404).send({
+          error: 'NotFound',
+          message: `No activity stats found for app: ${appId}`,
+        });
+      }
+
+      return reply.status(200).send({ ok: true });
+    },
+  );
+
+  // GET /api/activity/:handleOrDid/teaser -- 3-5 recent items for profile activity card
+  app.get<{ Params: { handleOrDid: string } }>(
+    '/api/activity/:handleOrDid/teaser',
+    async (request, reply) => {
+      const { handleOrDid } = request.params;
+
+      const did = await resolveHandleOrDid(db, handleOrDid);
+      if (!did) {
+        return reply.status(404).send({ error: 'NotFound', message: 'User not found' });
+      }
+
+      const suppressed = await isDidSuppressed(db, did);
+      if (suppressed) {
+        return reply.send({ items: [] });
+      }
+
+      const stats = await getVisibleAppStats(db, did);
+      const topApps = stats.slice(0, 3);
+
+      if (topApps.length === 0) {
+        return reply.send({ items: [] });
+      }
+
+      // Check Valkey cache
+      const cacheKey = `activity-teaser:${did}`;
+      if (valkey) {
+        try {
+          const cached = await valkey.get(cacheKey);
+          if (cached !== null) {
+            return reply.send(JSON.parse(cached));
+          }
+        } catch (err) {
+          request.log.warn({ err, cacheKey }, 'valkey.get failed for activity teaser');
+        }
+      }
+
+      const pdsHost = await resolvePdsHost(did);
+      const registry = getAppsRegistry();
+
+      // Build fetch promises for each top app
+      const fetchPromises = topApps.map((stat) => {
+        const entry = registry.find((e) => e.id === stat.appId);
+        if (!entry) return Promise.resolve([]);
+
+        if (entry.id === 'bluesky') {
+          return fetchBlueskyItems(did, 2);
+        }
+
+        if (!pdsHost) return Promise.resolve([]);
+        const collection = getCollectionForApp(entry);
+        return fetchPdsItems(pdsHost, did, collection, entry, 2).then((r) => r.items);
+      });
+
+      const results = await Promise.allSettled(fetchPromises);
+
+      const allItems: ActivityItem[] = [];
+      for (const result of results) {
+        if (result.status === 'fulfilled' && Array.isArray(result.value)) {
+          // Take up to 2 items per app
+          allItems.push(...result.value.slice(0, 2));
+        }
+      }
+
+      // Sort by date descending, take up to 5
+      allItems.sort((a, b) => new Date(b.indexedAt).getTime() - new Date(a.indexedAt).getTime());
+      const items = allItems.slice(0, 5);
+
+      const responseBody = { items };
+
+      // Cache result
+      if (valkey) {
+        try {
+          await valkey.set(cacheKey, JSON.stringify(responseBody), 'EX', 900);
+        } catch (err) {
+          request.log.warn({ err, cacheKey }, 'valkey.set failed for activity teaser');
+        }
+      }
+
+      return reply.send(responseBody);
+    },
+  );
+
+  // GET /api/activity/:handleOrDid -- full paginated activity feed
+  app.get<{
+    Params: { handleOrDid: string };
+    Querystring: { category?: string; limit?: string; cursor?: string };
+  }>('/api/activity/:handleOrDid', async (request, reply) => {
+    const { handleOrDid } = request.params;
+    const categoryParam = request.query.category ?? 'all';
+    const limitParam = Math.min(Math.max(parseInt(request.query.limit ?? '20', 10) || 20, 1), 50);
+    const cursorParam = request.query.cursor ?? null;
+
+    const did = await resolveHandleOrDid(db, handleOrDid);
+    if (!did) {
+      return reply.status(404).send({ error: 'NotFound', message: 'User not found' });
+    }
+
+    const suppressed = await isDidSuppressed(db, did);
+    if (suppressed) {
+      return reply.send({ items: [], cursor: null, hasMore: false });
+    }
+
+    const stats = await getVisibleAppStats(db, did);
+    const registry = getAppsRegistry();
+
+    // Filter apps by category if specified
+    let targetApps: { stat: (typeof stats)[number]; entry: AppRegistryEntry }[];
+    if (categoryParam === 'all') {
+      targetApps = stats
+        .slice(0, 5)
+        .map((stat) => {
+          const entry = registry.find((e) => e.id === stat.appId);
+          return entry ? { stat, entry } : null;
+        })
+        .filter((x): x is NonNullable<typeof x> => x !== null);
+    } else {
+      targetApps = stats
+        .map((stat) => {
+          const entry = registry.find((e) => e.id === stat.appId);
+          return entry && entry.category === categoryParam ? { stat, entry } : null;
+        })
+        .filter((x): x is NonNullable<typeof x> => x !== null);
+    }
+
+    if (targetApps.length === 0) {
+      return reply.send({ items: [], cursor: null, hasMore: false });
+    }
+
+    // Decode composite cursor
+    let perCollectionCursors: Record<string, string> = {};
+    if (cursorParam) {
+      try {
+        const decoded = JSON.parse(
+          Buffer.from(cursorParam, 'base64url').toString('utf-8'),
+        ) as CompositeCursor;
+        perCollectionCursors = decoded.cursors;
+      } catch {
+        return reply.status(400).send({ error: 'BadRequest', message: 'Invalid cursor' });
+      }
+    }
+
+    const pdsHost = await resolvePdsHost(did);
+
+    // Per-app limit: fetch a bit more per source to allow merge-sorting
+    const perAppLimit = Math.min(limitParam, 20);
+
+    // Build fetch promises
+    const fetchPromises = targetApps.map(({ entry }) => {
+      const collection = getCollectionForApp(entry);
+      const collectionCursor = perCollectionCursors[collection] ?? undefined;
+
+      // Check Valkey cache for this collection+cursor combo
+      const collCacheKey = `activity:${did}:${collection}:${collectionCursor ?? 'start'}`;
+
+      const fetchFn = async (): Promise<{
+        items: ActivityItem[];
+        cursor: string | undefined;
+        collection: string;
+      }> => {
+        // Try cache first
+        if (valkey) {
+          try {
+            const cached = await valkey.get(collCacheKey);
+            if (cached !== null) {
+              return JSON.parse(cached) as {
+                items: ActivityItem[];
+                cursor: string | undefined;
+                collection: string;
+              };
+            }
+          } catch (err) {
+            request.log.warn({ err, collCacheKey }, 'valkey.get failed for activity feed');
+          }
+        }
+
+        let result: { items: ActivityItem[]; cursor: string | undefined };
+
+        if (entry.id === 'bluesky') {
+          result = await fetchBlueskyFeedPaginated(did, perAppLimit, collectionCursor);
+        } else if (pdsHost) {
+          result = await fetchPdsItems(
+            pdsHost,
+            did,
+            collection,
+            entry,
+            perAppLimit,
+            collectionCursor,
+          );
+        } else {
+          result = { items: [], cursor: undefined };
+        }
+
+        const cacheValue = { ...result, collection };
+
+        // Cache the result
+        if (valkey) {
+          try {
+            await valkey.set(collCacheKey, JSON.stringify(cacheValue), 'EX', 300);
+          } catch (err) {
+            request.log.warn({ err, collCacheKey }, 'valkey.set failed for activity feed');
+          }
+        }
+
+        return cacheValue;
+      };
+
+      return fetchFn();
+    });
+
+    const results = await Promise.allSettled(fetchPromises);
+
+    // Merge all items and build new composite cursor
+    const allItems: ActivityItem[] = [];
+    const newCursors: Record<string, string> = {};
+
+    for (const result of results) {
+      if (result.status === 'fulfilled') {
+        allItems.push(...result.value.items);
+        if (result.value.cursor) {
+          newCursors[result.value.collection] = result.value.cursor;
+        }
+      }
+    }
+
+    // Sort by date descending
+    allItems.sort((a, b) => new Date(b.indexedAt).getTime() - new Date(a.indexedAt).getTime());
+
+    // Paginate
+    const items = allItems.slice(0, limitParam);
+    const hasMore = Object.keys(newCursors).length > 0;
+
+    const compositeCursor = hasMore
+      ? Buffer.from(JSON.stringify({ cursors: newCursors }), 'utf-8').toString('base64url')
+      : null;
+
+    return reply.send({ items, cursor: compositeCursor, hasMore });
+  });
+
+  // POST /api/privacy/suppress -- GDPR erasure endpoint (no auth required)
+  app.post('/api/privacy/suppress', async (request, reply) => {
+    const parsed = suppressSchema.safeParse(request.body);
+    if (!parsed.success) {
+      return reply.status(400).send({ error: 'ValidationError', issues: parsed.error.issues });
+    }
+
+    const did = await resolveHandleOrDid(db, parsed.data.handleOrDid);
+    if (!did) {
+      return reply.status(404).send({ error: 'NotFound', message: 'User not found' });
+    }
+
+    if (!valkey) {
+      return reply
+        .status(503)
+        .send({ error: 'ServiceUnavailable', message: 'Cache not available' });
+    }
+
+    await suppressDid(db, valkey, did);
+
+    return reply.send({ ok: true });
+  });
+}

src/routes/apps.ts

···
+import type { FastifyInstance } from 'fastify';
+import type { ValkeyClient } from '../cache/index.js';
+import { getAppsRegistry } from '../lib/atproto-app-registry.js';
+
+const APPS_REGISTRY_KEY = 'apps:registry';
+const APPS_REGISTRY_TTL = 86400; // 24 hours
+
+export function registerAppsRoutes(app: FastifyInstance, valkey: ValkeyClient | null) {
+  app.get('/api/apps/registry', async (_request, reply) => {
+    if (valkey) {
+      const cached = await valkey.get(APPS_REGISTRY_KEY);
+      if (cached !== null) {
+        return reply.send(JSON.parse(cached));
+      }
+    }
+
+    const registry = getAppsRegistry();
+
+    if (valkey) {
+      await valkey.setex(APPS_REGISTRY_KEY, APPS_REGISTRY_TTL, JSON.stringify(registry));
+    }
+
+    return reply.send(registry);
+  });
+}

src/routes/profile-write.ts

···
   sessions as sessionsTable,
   oauthSessions as oauthSessionsTable,
 } from '../db/schema/index.js';
+import { scanUserApps } from '../services/pds-scanner.js';
+import { upsertScanResults } from '../services/app-stats.js';
+import { resolvePdsHost } from '../lib/pds-provider.js';
 
 const overrideSchema = z.object({
   headline: z.string().max(300).nullish(),
···
     }
 
     app.log.info({ did, synced }, 'Profile synced from PDS');
+
+    // Scan cross-app activity (blocking at claim time so badges are ready immediately)
+    try {
+      const pdsHost = await resolvePdsHost(did);
+      if (pdsHost) {
+        const scanResults = await scanUserApps(`https://${pdsHost}`, did);
+        await upsertScanResults(db, did, scanResults);
+      }
+    } catch (err) {
+      app.log.warn({ err, did }, 'Cross-app activity scan failed during profile sync');
+      // Non-fatal — profile sync still succeeds even if activity scan fails
+    }
+
     return reply.send({ synced });
   });
 

src/routes/profile.ts

···
 import { isVerifiablePlatform } from '../services/verification.js';
 import { resolveProfileFields } from '../lib/resolve-profile.js';
 import { resolvePdsHost, mapPdsHostToProvider } from '../lib/pds-provider.js';
+import {
+  getVisibleAppStats,
+  triggerRefreshIfStale,
+  isDidSuppressed,
+} from '../services/app-stats.js';
+import { getAppsRegistry } from '../lib/atproto-app-registry.js';
 
 export async function getMutualFollowCount(db: Database, did: string): Promise<number> {
   // Raw SQL required: Drizzle ORM doesn't support self-join aggregate subqueries for mutual follow counting
···
             followingCount: 0,
             connectionsCount: 0,
             atprotoFollowersCount: bskyFollowers,
+            activeApps: [],
             inviteCount: inviteCountResult[0]?.value ?? 0,
             pdsProvider: pdsHost ? mapPdsHostToProvider(pdsHost) : null,
             claimed: false,
···
       const followersCount = followersResult[0]?.value ?? 0;
       const followingCount = followingResult[0]?.value ?? 0;
 
+      // Fetch active apps (cross-app activity) in parallel
+      const [suppressed, visibleStats] = await Promise.all([
+        isDidSuppressed(db, profile.did),
+        getVisibleAppStats(db, profile.did),
+      ]);
+
+      const registry = getAppsRegistry();
+      const activeApps = suppressed
+        ? []
+        : visibleStats
+            .filter((s) => s.isActive)
+            .map((s) => {
+              const registryEntry = registry.find((r) => r.id === s.appId);
+              return {
+                id: s.appId,
+                name: registryEntry?.name ?? s.appId,
+                category: registryEntry?.category ?? 'Other',
+                recentCount: s.recentCount,
+                latestRecordAt: s.latestRecordAt?.toISOString() ?? null,
+              };
+            });
+
       // Assemble location display string from parts
       const locationParts = [
         profile.locationCity,
···
           .catch((err: unknown) => {
             request.log.warn({ err, did: profile.did }, 'Failed to cache pdsHost');
           });
+      }
+
+      // Trigger background PDS scan if data is stale (fire-and-forget)
+      if (valkey && pdsHost) {
+        triggerRefreshIfStale(db, valkey, profile.did, pdsHost);
       }
 
       // Find primary external account for website display
···
         followersCount,
         followingCount,
         connectionsCount: connectionsCountResult,
+        activeApps,
         atprotoFollowersCount: atprotoFollowersCount ?? 0,
         inviteCount: inviteCountResult[0]?.value ?? 0,
         pdsProvider: pdsHost ? mapPdsHostToProvider(pdsHost) : null,

src/server.ts

···
 import { createHonorIndexer } from './jetstream/indexers/honor.js';
 import { createLanguageIndexer } from './jetstream/indexers/language.js';
 import { createCursorManager } from './jetstream/cursor.js';
+import { registerActivityRoutes } from './routes/activity.js';
+import { registerAppsRoutes } from './routes/apps.js';
 import { registerFeaturedRoutes } from './routes/featured.js';
 import { startFeaturedProfileJob } from './services/featured-job.js';
 import { createBotAgent } from './services/bluesky-bot.js';
···
   registerStatsRoutes(app, db, valkey);
   registerAdminStatsRoutes(app, db, valkey, oauthClient, config);
   registerLocationRoutes(app, config.GEONAMES_USERNAME);
+  registerActivityRoutes(app, db, oauthClient, valkey);
+  registerAppsRoutes(app, valkey);
   registerFeaturedRoutes(app, db, valkey);
 
   // Start Jetstream in non-test mode

src/services/app-stats.ts

···
+import { eq, and, desc, notInArray } from 'drizzle-orm';
+import type { Database } from '../db/index.js';
+import type { ValkeyClient } from '../cache/index.js';
+import { userAppStats } from '../db/schema/user-app-stats.js';
+import { suppressedDids } from '../db/schema/suppressed-dids.js';
+import { scanUserApps, type AppScanResult } from './pds-scanner.js';
+
+export interface AppStatRow {
+  did: string;
+  appId: string;
+  isActive: boolean;
+  recentCount: number;
+  latestRecordAt: Date | null;
+  refreshedAt: Date;
+  visible: boolean;
+  createdAt: Date;
+}
+
+const STALE_THRESHOLD_MS = 24 * 60 * 60 * 1000; // 24 hours
+const LOCK_TTL_SECONDS = 120;
+
+export async function getAppStatsForDid(db: Database, did: string): Promise<AppStatRow[]> {
+  return db
+    .select()
+    .from(userAppStats)
+    .where(eq(userAppStats.did, did))
+    .orderBy(desc(userAppStats.recentCount));
+}
+
+export async function getVisibleAppStats(db: Database, did: string): Promise<AppStatRow[]> {
+  return db
+    .select()
+    .from(userAppStats)
+    .where(and(eq(userAppStats.did, did), eq(userAppStats.visible, true)))
+    .orderBy(desc(userAppStats.recentCount));
+}
+
+export async function upsertScanResults(
+  db: Database,
+  did: string,
+  results: AppScanResult[],
+): Promise<void> {
+  if (results.length === 0) {
+    // Delete all rows for this DID if no results
+    await db.delete(userAppStats).where(eq(userAppStats.did, did));
+    return;
+  }
+
+  const now = new Date();
+
+  // Upsert each result
+  for (const result of results) {
+    await db
+      .insert(userAppStats)
+      .values({
+        did,
+        appId: result.appId,
+        isActive: result.isActive,
+        recentCount: result.recentCount,
+        latestRecordAt: result.latestRecordAt,
+        refreshedAt: now,
+      })
+      .onConflictDoUpdate({
+        target: [userAppStats.did, userAppStats.appId],
+        set: {
+          isActive: result.isActive,
+          recentCount: result.recentCount,
+          latestRecordAt: result.latestRecordAt,
+          refreshedAt: now,
+        },
+      });
+  }
+
+  // Delete rows for apps not in the results
+  const resultAppIds = results.map((r) => r.appId);
+  await db
+    .delete(userAppStats)
+    .where(and(eq(userAppStats.did, did), notInArray(userAppStats.appId, resultAppIds)));
+}
+
+function isStale(rows: AppStatRow[]): boolean {
+  if (rows.length === 0) return true;
+
+  const now = Date.now();
+  return rows.every((row) => now - row.refreshedAt.getTime() >= STALE_THRESHOLD_MS);
+}
+
+export function triggerRefreshIfStale(
+  db: Database,
+  valkey: ValkeyClient,
+  did: string,
+  pdsHost: string,
+): void {
+  // Fire-and-forget — caller does not await
+  void (async () => {
+    // Check staleness
+    const rows = await getAppStatsForDid(db, did);
+    if (!isStale(rows)) return;
+
+    // Acquire lock
+    const lockKey = `pds-scan:${did}`;
+    const locked = await valkey.set(lockKey, '1', 'EX', LOCK_TTL_SECONDS, 'NX');
+    if (locked === null) return; // another scan is running
+
+    try {
+      const results = await scanUserApps(pdsHost, did);
+      await upsertScanResults(db, did, results);
+    } catch (err) {
+      console.error(`Background PDS scan failed for ${did}:`, err);
+      // Release lock early on failure
+      await valkey.del(lockKey).catch(() => {});
+    }
+  })().catch((err) => {
+    console.error(`Unexpected error in triggerRefreshIfStale for ${did}:`, err);
+  });
+}
+
+export async function isDidSuppressed(db: Database, did: string): Promise<boolean> {
+  const rows = await db.select().from(suppressedDids).where(eq(suppressedDids.did, did));
+  return rows.length > 0;
+}
+
+export async function suppressDid(db: Database, valkey: ValkeyClient, did: string): Promise<void> {
+  // Insert into suppressed list
+  await db.insert(suppressedDids).values({ did }).onConflictDoNothing();
+
+  // Delete all stats for this DID
+  await db.delete(userAppStats).where(eq(userAppStats.did, did));
+
+  // Clean up Valkey keys
+  await valkey.del(`pds-scan:${did}`);
+  await valkey.del(`activity-teaser:${did}`);
+  const activityKeys = await valkey.keys(`activity:${did}:*`);
+  if (activityKeys.length > 0) {
+    await valkey.del(...activityKeys);
+  }
+}

src/services/pds-scanner.ts

···
+import { Agent } from '@atproto/api';
+import { getAppsRegistry, EXCLUDED_COLLECTIONS } from '../lib/atproto-app-registry.js';
+
+export interface AppScanResult {
+  appId: string;
+  isActive: boolean;
+  recentCount: number;
+  latestRecordAt: Date | null;
+}
+
+const MAX_PAGES = 5;
+const PAGE_LIMIT = 100;
+const RECENT_WINDOW_DAYS = 90;
+const REQUEST_TIMEOUT_MS = 5000;
+
+function getRecentWindowStart(): Date {
+  const d = new Date();
+  d.setDate(d.getDate() - RECENT_WINDOW_DAYS);
+  return d;
+}
+
+function getCollectionsForApp(app: {
+  scanCollections: string[];
+  collectionPrefixes: string[];
+}): string[] {
+  const collections =
+    app.scanCollections.length > 0
+      ? [...app.scanCollections]
+      : app.collectionPrefixes.length > 0
+        ? [app.collectionPrefixes[0] ?? ''].filter(Boolean)
+        : [];
+
+  return collections.filter((c) => !EXCLUDED_COLLECTIONS.includes(c));
+}
+
+interface RecordValue {
+  createdAt?: string;
+}
+
+async function scanCollection(
+  agent: Agent,
+  did: string,
+  collection: string,
+): Promise<{ recentCount: number; latestRecordAt: Date | null }> {
+  const windowStart = getRecentWindowStart();
+  let recentCount = 0;
+  let latestRecordAt: Date | null = null;
+  let cursor: string | undefined;
+
+  for (let page = 0; page < MAX_PAGES; page++) {
+    const res = await agent.com.atproto.repo.listRecords(
+      {
+        repo: did,
+        collection,
+        limit: PAGE_LIMIT,
+        cursor,
+      },
+      { signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS) },
+    );
+
+    const records = res.data.records;
+    if (records.length === 0) break;
+
+    let allOutsideWindow = true;
+
+    for (const record of records) {
+      const val = record.value as RecordValue;
+      if (!val.createdAt) continue;
+
+      const recordDate = new Date(val.createdAt);
+
+      if (latestRecordAt === null || recordDate > latestRecordAt) {
+        latestRecordAt = recordDate;
+      }
+
+      if (recordDate >= windowStart) {
+        recentCount++;
+        allOutsideWindow = false;
+      }
+    }
+
+    if (allOutsideWindow) break;
+
+    cursor = res.data.cursor;
+    if (!cursor) break;
+  }
+
+  return { recentCount, latestRecordAt };
+}
+
+async function scanApp(
+  agent: Agent,
+  did: string,
+  appId: string,
+  collections: string[],
+): Promise<AppScanResult> {
+  if (collections.length === 0) {
+    return { appId, isActive: false, recentCount: 0, latestRecordAt: null };
+  }
+
+  const collectionResults = await Promise.allSettled(
+    collections.map((c) => scanCollection(agent, did, c)),
+  );
+
+  let totalRecentCount = 0;
+  let overallLatest: Date | null = null;
+
+  for (const result of collectionResults) {
+    if (result.status !== 'fulfilled') continue;
+    totalRecentCount += result.value.recentCount;
+    if (
+      result.value.latestRecordAt !== null &&
+      (overallLatest === null || result.value.latestRecordAt > overallLatest)
+    ) {
+      overallLatest = result.value.latestRecordAt;
+    }
+  }
+
+  return {
+    appId,
+    isActive: totalRecentCount > 0,
+    recentCount: totalRecentCount,
+    latestRecordAt: overallLatest,
+  };
+}
+
+export async function scanUserApps(pdsUrl: string, did: string): Promise<AppScanResult[]> {
+  const agent = new Agent(pdsUrl);
+  const registry = getAppsRegistry();
+
+  const scanPromises = registry.map((app) => {
+    const collections = getCollectionsForApp(app);
+    return scanApp(agent, did, app.id, collections);
+  });
+
+  const results = await Promise.allSettled(scanPromises);
+
+  return results.map((result, i) => {
+    if (result.status === 'fulfilled') {
+      return result.value;
+    }
+    return {
+      appId: registry[i]?.id ?? 'unknown',
+      isActive: false,
+      recentCount: 0,
+      latestRecordAt: null,
+    };
+  });
+}

tests/lib/atproto-app-registry.test.ts

···
+import { describe, expect, it } from 'vitest';
+import {
+  EXCLUDED_COLLECTIONS,
+  getAppForCollection,
+  getAppsRegistry,
+} from '../../src/lib/atproto-app-registry.js';
+
+describe('atproto-app-registry', () => {
+  describe('getAppsRegistry', () => {
+    it('returns all entries with required fields', () => {
+      const registry = getAppsRegistry();
+      expect(registry.length).toBeGreaterThan(0);
+      for (const entry of registry) {
+        expect(entry.id).toBeTruthy();
+        expect(entry.name).toBeTruthy();
+        expect(entry.category).toBeTruthy();
+        expect(entry.collectionPrefixes.length).toBeGreaterThan(0);
+        expect(entry.color).toBeTruthy();
+        expect(Array.isArray(entry.scanCollections)).toBe(true);
+      }
+    });
+  });
+
+  describe('getAppForCollection', () => {
+    it('maps known collection to its app via scanCollections', () => {
+      const result = getAppForCollection('app.bsky.feed.post');
+      expect(result).toBeDefined();
+      expect(result?.id).toBe('bluesky');
+      expect(result?.matchedPrefix).toBe('app.bsky.feed');
+    });
+
+    it('maps com.whtwnd.blog.entry to whitewind via scanCollections', () => {
+      const result = getAppForCollection('com.whtwnd.blog.entry');
+      expect(result).toBeDefined();
+      expect(result?.id).toBe('whitewind');
+      expect(result?.matchedPrefix).toBe('com.whtwnd');
+    });
+
+    it('maps by prefix for unknown sub-collections', () => {
+      const result = getAppForCollection('sh.tangled.some.new');
+      expect(result).toBeDefined();
+      expect(result?.id).toBe('tangled');
+      expect(result?.matchedPrefix).toBe('sh.tangled');
+    });
+
+    it('maps events.smokesignal.foo by prefix', () => {
+      const result = getAppForCollection('events.smokesignal.foo');
+      expect(result).toBeDefined();
+      expect(result?.id).toBe('smokesignal');
+    });
+
+    it('returns undefined for unknown collections', () => {
+      const result = getAppForCollection('com.unknown.something');
+      expect(result).toBeUndefined();
+    });
+
+    it('prefers scanCollections exact match over prefix match', () => {
+      // app.bsky.feed.post should match bluesky via scanCollections,
+      // not just prefix
+      const result = getAppForCollection('app.bsky.feed.post');
+      expect(result?.id).toBe('bluesky');
+    });
+  });
+
+  describe('EXCLUDED_COLLECTIONS', () => {
+    it('contains expected entries', () => {
+      expect(EXCLUDED_COLLECTIONS).toContain('app.bsky.feed.like');
+      expect(EXCLUDED_COLLECTIONS).toContain('app.bsky.feed.repost');
+      expect(EXCLUDED_COLLECTIONS).toContain('app.bsky.graph.follow');
+      expect(EXCLUDED_COLLECTIONS).toContain('app.bsky.graph.block');
+      expect(EXCLUDED_COLLECTIONS).toContain('app.bsky.graph.mute');
+      expect(EXCLUDED_COLLECTIONS).toContain('app.bsky.graph.listitem');
+    });
+
+    it('has exactly 6 entries', () => {
+      expect(EXCLUDED_COLLECTIONS).toHaveLength(6);
+    });
+  });
+});

tests/services/app-stats.test.ts

···
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Mock pds-scanner
+const mockScanUserApps = vi.fn();
+vi.mock('../../src/services/pds-scanner.js', () => ({
+  scanUserApps: mockScanUserApps,
+}));
+
+// Mock drizzle-orm operators — return tagged objects so we can assert calls
+vi.mock('drizzle-orm', () => ({
+  eq: vi.fn((col, val) => ({ _op: 'eq', col, val })),
+  and: vi.fn((...args: unknown[]) => ({ _op: 'and', args })),
+  desc: vi.fn((col) => ({ _op: 'desc', col })),
+  lt: vi.fn((col, val) => ({ _op: 'lt', col, val })),
+  notInArray: vi.fn((col, vals) => ({ _op: 'notInArray', col, vals })),
+}));
+
+import type { AppScanResult } from '../../src/services/pds-scanner.js';
+import type { AppStatRow } from '../../src/services/app-stats.js';
+
+// ---- Mock DB builder ----
+function createMockDb() {
+  const mockDeleteWhere = vi.fn().mockResolvedValue(undefined);
+  const mockDeleteObj = { where: mockDeleteWhere };
+  const mockOnConflictDoUpdate = vi.fn().mockResolvedValue(undefined);
+  const mockOnConflictDoNothing = vi.fn().mockResolvedValue(undefined);
+  const mockInsertValues = vi.fn().mockReturnValue({
+    onConflictDoUpdate: mockOnConflictDoUpdate,
+    onConflictDoNothing: mockOnConflictDoNothing,
+  });
+  const mockSelectWhere = vi.fn().mockReturnValue({
+    orderBy: vi.fn().mockResolvedValue([]),
+  });
+  const mockSelectFrom = vi.fn().mockReturnValue({
+    where: mockSelectWhere,
+  });
+
+  const db = {
+    select: vi.fn().mockReturnValue({ from: mockSelectFrom }),
+    insert: vi.fn().mockReturnValue({ values: mockInsertValues }),
+    delete: vi.fn().mockReturnValue(mockDeleteObj),
+    _mocks: {
+      selectFrom: mockSelectFrom,
+      selectWhere: mockSelectWhere,
+      insertValues: mockInsertValues,
+      onConflictDoUpdate: mockOnConflictDoUpdate,
+      onConflictDoNothing: mockOnConflictDoNothing,
+      deleteObj: mockDeleteObj,
+      deleteWhere: mockDeleteWhere,
+    },
+  } as unknown;
+
+  return db as ReturnType<typeof createMockDb> & {
+    select: ReturnType<typeof vi.fn>;
+    insert: ReturnType<typeof vi.fn>;
+    delete: ReturnType<typeof vi.fn>;
+    _mocks: {
+      selectFrom: ReturnType<typeof vi.fn>;
+      selectWhere: ReturnType<typeof vi.fn>;
+      insertValues: ReturnType<typeof vi.fn>;
+      onConflictDoUpdate: ReturnType<typeof vi.fn>;
+      onConflictDoNothing: ReturnType<typeof vi.fn>;
+      deleteObj: { where: ReturnType<typeof vi.fn> };
+      deleteWhere: ReturnType<typeof vi.fn>;
+    };
+  };
+}
+
+// ---- Mock Valkey ----
+function createMockValkey() {
+  return {
+    set: vi.fn(),
+    del: vi.fn().mockResolvedValue(1),
+    keys: vi.fn().mockResolvedValue([]),
+  } as unknown as ReturnType<typeof createMockValkey> & {
+    set: ReturnType<typeof vi.fn>;
+    del: ReturnType<typeof vi.fn>;
+    keys: ReturnType<typeof vi.fn>;
+  };
+}
+
+describe('app-stats service', () => {
+  let db: ReturnType<typeof createMockDb>;
+  let valkey: ReturnType<typeof createMockValkey>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.useFakeTimers();
+    db = createMockDb();
+    valkey = createMockValkey();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  // We import dynamically after mocks are set up
+  async function getModule() {
+    return import('../../src/services/app-stats.js');
+  }
+
+  describe('getVisibleAppStats', () => {
+    it('returns only visible rows ordered by recentCount DESC', async () => {
+      const { getVisibleAppStats } = await getModule();
+
+      const visibleRows: AppStatRow[] = [
+        {
+          did: 'did:plc:test',
+          appId: 'bluesky',
+          isActive: true,
+          recentCount: 42,
+          latestRecordAt: new Date(),
+          refreshedAt: new Date(),
+          visible: true,
+          createdAt: new Date(),
+        },
+        {
+          did: 'did:plc:test',
+          appId: 'whitewind',
+          isActive: true,
+          recentCount: 5,
+          latestRecordAt: new Date(),
+          refreshedAt: new Date(),
+          visible: true,
+          createdAt: new Date(),
+        },
+      ];
+
+      const mockOrderBy = vi.fn().mockResolvedValue(visibleRows);
+      db._mocks.selectWhere.mockReturnValue({ orderBy: mockOrderBy });
+
+      const result = await getVisibleAppStats(db as never, 'did:plc:test');
+
+      expect(result).toEqual(visibleRows);
+      expect(result[0]?.recentCount).toBeGreaterThan(result[1]?.recentCount ?? 0);
+      expect(db.select).toHaveBeenCalled();
+    });
+  });
+
+  describe('upsertScanResults', () => {
+    it('calls Drizzle upsert for each scan result', async () => {
+      const { upsertScanResults } = await getModule();
+
+      const results: AppScanResult[] = [
+        { appId: 'bluesky', isActive: true, recentCount: 10, latestRecordAt: new Date() },
+        { appId: 'whitewind', isActive: false, recentCount: 0, latestRecordAt: null },
+      ];
+
+      await upsertScanResults(db as never, 'did:plc:test', results);
+
+      // Should have called insert for the batch
+      expect(db.insert).toHaveBeenCalled();
+      expect(db._mocks.insertValues).toHaveBeenCalled();
+      expect(db._mocks.onConflictDoUpdate).toHaveBeenCalled();
+    });
+  });
+
+  describe('triggerRefreshIfStale', () => {
+    it('acquires Valkey lock before scanning', async () => {
+      const { triggerRefreshIfStale } = await getModule();
+
+      // No rows exist — stale
+      const mockOrderBy = vi.fn().mockResolvedValue([]);
+      db._mocks.selectWhere.mockReturnValue({ orderBy: mockOrderBy });
+
+      // Lock acquired
+      valkey.set.mockResolvedValue('OK');
+      mockScanUserApps.mockResolvedValue([]);
+
+      triggerRefreshIfStale(
+        db as never,
+        valkey as never,
+        'did:plc:test',
+        'https://pds.example.com',
+      );
+
+      // Let the microtask queue flush
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(valkey.set).toHaveBeenCalledWith(
+        'pds-scan:did:plc:test',
+        expect.any(String),
+        'EX',
+        120,
+        'NX',
+      );
+      expect(mockScanUserApps).toHaveBeenCalledWith('https://pds.example.com', 'did:plc:test');
+    });
+
+    it('skips if lock already held', async () => {
+      const { triggerRefreshIfStale } = await getModule();
+
+      // No rows — stale
+      const mockOrderBy = vi.fn().mockResolvedValue([]);
+      db._mocks.selectWhere.mockReturnValue({ orderBy: mockOrderBy });
+
+      // Lock NOT acquired
+      valkey.set.mockResolvedValue(null);
+
+      triggerRefreshIfStale(
+        db as never,
+        valkey as never,
+        'did:plc:test',
+        'https://pds.example.com',
+      );
+
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(valkey.set).toHaveBeenCalled();
+      expect(mockScanUserApps).not.toHaveBeenCalled();
+    });
+
+    it('skips if data is fresh (refreshedAt < 24h old)', async () => {
+      const { triggerRefreshIfStale } = await getModule();
+
+      const freshRow: AppStatRow = {
+        did: 'did:plc:test',
+        appId: 'bluesky',
+        isActive: true,
+        recentCount: 10,
+        latestRecordAt: new Date(),
+        refreshedAt: new Date(), // just now — fresh
+        visible: true,
+        createdAt: new Date(),
+      };
+
+      const mockOrderBy = vi.fn().mockResolvedValue([freshRow]);
+      db._mocks.selectWhere.mockReturnValue({ orderBy: mockOrderBy });
+
+      triggerRefreshIfStale(
+        db as never,
+        valkey as never,
+        'did:plc:test',
+        'https://pds.example.com',
+      );
+
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(valkey.set).not.toHaveBeenCalled();
+      expect(mockScanUserApps).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('isDidSuppressed', () => {
+    it('returns true when DID exists in suppressed table', async () => {
+      const { isDidSuppressed } = await getModule();
+
+      const mockOrderBy = vi.fn().mockResolvedValue([{ did: 'did:plc:bad' }]);
+      db._mocks.selectWhere.mockReturnValue({ orderBy: mockOrderBy });
+      // For suppressedDids, we use a simpler select pattern
+      db._mocks.selectWhere.mockResolvedValue([{ did: 'did:plc:bad' }]);
+
+      const result = await isDidSuppressed(db as never, 'did:plc:bad');
+      expect(result).toBe(true);
+    });
+
+    it('returns false when DID is not suppressed', async () => {
+      const { isDidSuppressed } = await getModule();
+
+      db._mocks.selectWhere.mockResolvedValue([]);
+
+      const result = await isDidSuppressed(db as never, 'did:plc:good');
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('suppressDid', () => {
+    it('inserts suppression, deletes stats, and clears Valkey keys', async () => {
+      const { suppressDid } = await getModule();
+
+      valkey.keys.mockResolvedValue(['activity:did:plc:bad:bluesky']);
+
+      await suppressDid(db as never, valkey as never, 'did:plc:bad');
+
+      // Should insert into suppressedDids
+      expect(db.insert).toHaveBeenCalled();
+      expect(db._mocks.onConflictDoNothing).toHaveBeenCalled();
+
+      // Should delete userAppStats
+      expect(db.delete).toHaveBeenCalled();
+
+      // Should delete Valkey keys
+      expect(valkey.del).toHaveBeenCalledWith('pds-scan:did:plc:bad');
+      expect(valkey.del).toHaveBeenCalledWith('activity-teaser:did:plc:bad');
+      expect(valkey.keys).toHaveBeenCalledWith('activity:did:plc:bad:*');
+    });
+  });
+});
+
+// Need afterEach at module level for vitest
+import { afterEach } from 'vitest';

tests/services/pds-scanner.test.ts

···
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { AppRegistryEntry } from '../../src/lib/atproto-app-registry.js';
+
+// Mock the app registry
+vi.mock('../../src/lib/atproto-app-registry.js', () => ({
+  getAppsRegistry: vi.fn(),
+  EXCLUDED_COLLECTIONS: ['app.bsky.feed.like', 'app.bsky.feed.repost'],
+}));
+
+// Mock @atproto/api
+const mockListRecords = vi.fn();
+vi.mock('@atproto/api', () => {
+  class MockAgent {
+    com = {
+      atproto: {
+        repo: {
+          listRecords: mockListRecords,
+        },
+      },
+    };
+  }
+  return { Agent: MockAgent };
+});
+
+import { scanUserApps } from '../../src/services/pds-scanner.js';
+import { getAppsRegistry } from '../../src/lib/atproto-app-registry.js';
+
+const mockedGetAppsRegistry = vi.mocked(getAppsRegistry);
+
+function daysAgo(n: number): string {
+  const d = new Date();
+  d.setDate(d.getDate() - n);
+  return d.toISOString();
+}
+
+function makeRecord(createdAt: string, uri?: string) {
+  return {
+    uri: uri ?? 'at://did:plc:test/collection/rkey',
+    cid: 'bafytest',
+    value: { createdAt },
+  };
+}
+
+function makeRegistry(overrides: Partial<AppRegistryEntry>[] = []): AppRegistryEntry[] {
+  const defaults: AppRegistryEntry[] = [
+    {
+      id: 'bluesky',
+      name: 'Bluesky',
+      category: 'Posts',
+      collectionPrefixes: ['app.bsky.feed'],
+      scanCollections: ['app.bsky.feed.post'],
+      color: 'sky',
+    },
+    {
+      id: 'whitewind',
+      name: 'Whitewind',
+      category: 'Articles',
+      collectionPrefixes: ['com.whtwnd'],
+      scanCollections: ['com.whtwnd.blog.entry'],
+      color: 'slate',
+    },
+  ];
+  if (overrides.length > 0) {
+    return overrides.map((o, i) => ({
+      ...(defaults[i % defaults.length] as AppRegistryEntry),
+      ...o,
+    }));
+  }
+  return defaults;
+}
+
+describe('scanUserApps', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('calls listRecords for each scan collection', async () => {
+    mockedGetAppsRegistry.mockReturnValue(makeRegistry());
+    mockListRecords.mockResolvedValue({
+      data: { records: [], cursor: undefined },
+    });
+
+    await scanUserApps('https://pds.example.com', 'did:plc:test');
+
+    expect(mockListRecords).toHaveBeenCalledWith(
+      expect.objectContaining({
+        repo: 'did:plc:test',
+        collection: 'app.bsky.feed.post',
+        limit: 100,
+      }),
+      expect.anything(),
+    );
+    expect(mockListRecords).toHaveBeenCalledWith(
+      expect.objectContaining({
+        repo: 'did:plc:test',
+        collection: 'com.whtwnd.blog.entry',
+        limit: 100,
+      }),
+      expect.anything(),
+    );
+  });
+
+  it('counts records within the 90-day window', async () => {
+    mockedGetAppsRegistry.mockReturnValue(
+      makeRegistry([
+        {
+          id: 'bluesky',
+          name: 'Bluesky',
+          category: 'Posts',
+          collectionPrefixes: ['app.bsky.feed'],
+          scanCollections: ['app.bsky.feed.post'],
+          color: 'sky',
+        },
+      ]),
+    );
+
+    mockListRecords.mockResolvedValueOnce({
+      data: {
+        records: [
+          makeRecord(daysAgo(1)),
+          makeRecord(daysAgo(10)),
+          makeRecord(daysAgo(89)),
+          makeRecord(daysAgo(100)), // outside window
+        ],
+        cursor: undefined,
+      },
+    });
+
+    const results = await scanUserApps('https://pds.example.com', 'did:plc:test');
+    const bluesky = results.find((r) => r.appId === 'bluesky');
+
+    expect(bluesky).toBeDefined();
+    expect(bluesky?.recentCount).toBe(3);
+    expect(bluesky?.isActive).toBe(true);
+  });
+
+  it('stops pagination when all records fall outside the 90-day window', async () => {
+    mockedGetAppsRegistry.mockReturnValue(
+      makeRegistry([
+        {
+          id: 'bluesky',
+          name: 'Bluesky',
+          category: 'Posts',
+          collectionPrefixes: ['app.bsky.feed'],
+          scanCollections: ['app.bsky.feed.post'],
+          color: 'sky',
+        },
+      ]),
+    );
+
+    // Page 1: some recent records + cursor
+    mockListRecords.mockResolvedValueOnce({
+      data: {
+        records: [makeRecord(daysAgo(5)), makeRecord(daysAgo(30))],
+        cursor: 'page2',
+      },
+    });
+
+    // Page 2: all records outside window
+    mockListRecords.mockResolvedValueOnce({
+      data: {
+        records: [makeRecord(daysAgo(100)), makeRecord(daysAgo(120))],
+        cursor: 'page3',
+      },
+    });
+
+    await scanUserApps('https://pds.example.com', 'did:plc:test');
+
+    // Should NOT have fetched page 3
+    expect(mockListRecords).toHaveBeenCalledTimes(2);
+  });
+
+  it('skips excluded collections', async () => {
+    mockedGetAppsRegistry.mockReturnValue([
+      {
+        id: 'bluesky-likes',
+        name: 'Bluesky Likes',
+        category: 'Posts',
+        collectionPrefixes: ['app.bsky.feed'],
+        scanCollections: ['app.bsky.feed.like'], // excluded
+        color: 'sky',
+      },
+    ]);
+
+    mockListRecords.mockResolvedValue({
+      data: { records: [], cursor: undefined },
+    });
+
+    const results = await scanUserApps('https://pds.example.com', 'did:plc:test');
+
+    expect(mockListRecords).not.toHaveBeenCalled();
+    // Should still return a result for the app, but with zero counts
+    const likesApp = results.find((r) => r.appId === 'bluesky-likes');
+    expect(likesApp).toBeDefined();
+    expect(likesApp?.recentCount).toBe(0);
+    expect(likesApp?.isActive).toBe(false);
+  });
+
+  it('does not fail the entire scan when one collection errors', async () => {
+    mockedGetAppsRegistry.mockReturnValue(makeRegistry());
+
+    // Bluesky fails
+    mockListRecords.mockImplementation(async (params: { collection: string }) => {
+      if (params.collection === 'app.bsky.feed.post') {
+        throw new Error('PDS timeout');
+      }
+      return {
+        data: {
+          records: [makeRecord(daysAgo(5))],
+          cursor: undefined,
+        },
+      };
+    });
+
+    const results = await scanUserApps('https://pds.example.com', 'did:plc:test');
+
+    expect(results).toHaveLength(2);
+
+    const bluesky = results.find((r) => r.appId === 'bluesky');
+    expect(bluesky?.isActive).toBe(false);
+    expect(bluesky?.recentCount).toBe(0);
+
+    const whitewind = results.find((r) => r.appId === 'whitewind');
+    expect(whitewind?.isActive).toBe(true);
+    expect(whitewind?.recentCount).toBe(1);
+  });
+
+  it('captures the most recent latestRecordAt', async () => {
+    const recentDate = daysAgo(2);
+    const olderDate = daysAgo(50);
+
+    mockedGetAppsRegistry.mockReturnValue(
+      makeRegistry([
+        {
+          id: 'bluesky',
+          name: 'Bluesky',
+          category: 'Posts',
+          collectionPrefixes: ['app.bsky.feed'],
+          scanCollections: ['app.bsky.feed.post'],
+          color: 'sky',
+        },
+      ]),
+    );
+
+    mockListRecords.mockResolvedValueOnce({
+      data: {
+        records: [makeRecord(olderDate), makeRecord(recentDate)],
+        cursor: undefined,
+      },
+    });
+
+    const results = await scanUserApps('https://pds.example.com', 'did:plc:test');
+    const bluesky = results.find((r) => r.appId === 'bluesky');
+
+    expect(bluesky?.latestRecordAt).toEqual(new Date(recentDate));
+  });
+
+  it('uses first collectionPrefix when scanCollections is empty', async () => {
+    mockedGetAppsRegistry.mockReturnValue([
+      {
+        id: 'tangled',
+        name: 'Tangled',
+        category: 'Code',
+        collectionPrefixes: ['sh.tangled'],
+        scanCollections: [],
+        color: 'emerald',
+      },
+    ]);
+
+    mockListRecords.mockResolvedValue({
+      data: { records: [], cursor: undefined },
+    });
+
+    await scanUserApps('https://pds.example.com', 'did:plc:test');
+
+    expect(mockListRecords).toHaveBeenCalledWith(
+      expect.objectContaining({
+        collection: 'sh.tangled',
+      }),
+      expect.anything(),
+    );
+  });
+});