From 2cf77a1bb09b4ea7cc1e7bb0ec77e2b7488c7246 Mon Sep 17 00:00:00 2001
From: mmattbtw <matt@mmatt.net>
Date: Sun, 14 Jun 2026 20:04:37 -0500
Subject: [PATCH] feat(amethyst): add opt-in popfeed sync

Add a persisted settings toggle and sync manual scrobble submissions into Popfeed list/listItem records using the published social.popfeed lexicons. Skip duplicate track/album identifiers and cover the mapping/write behavior with focused tests.
---
 .../app/(tabs)/(stamp)/stamp/submit.tsx       |  16 +
 apps/amethyst/app/(tabs)/settings/index.tsx   |  20 +-
 apps/amethyst/lib/__tests__/popfeed.test.ts   | 156 +++++++++
 apps/amethyst/lib/popfeed.ts                  | 300 ++++++++++++++++++
 apps/amethyst/stores/preferenceSlice.tsx      |   4 +
 todo.md                                       |   2 +-
 6 files changed, 492 insertions(+), 6 deletions(-)
 create mode 100644 apps/amethyst/lib/__tests__/popfeed.test.ts
 create mode 100644 apps/amethyst/lib/popfeed.ts

diff --git a/apps/amethyst/app/(tabs)/(stamp)/stamp/submit.tsx b/apps/amethyst/app/(tabs)/(stamp)/stamp/submit.tsx
index 948cdd1..8d59b1c 100644
--- a/apps/amethyst/app/(tabs)/(stamp)/stamp/submit.tsx
+++ b/apps/amethyst/app/(tabs)/(stamp)/stamp/submit.tsx
@@ -7,6 +7,7 @@ import { Button } from "@/components/ui/button";
 import { Text } from "@/components/ui/text";
 import { Textarea } from "@/components/ui/textarea";
 import { MusicBrainzRecording, PlaySubmittedData } from "@/lib/oldStamp";
+import { syncPlayToPopfeed } from "@/lib/popfeed";
 import { cn } from "@/lib/utils";
 import { useStore } from "@/stores/mainStore";
 import {
@@ -160,6 +161,7 @@ const createPlayRecord = (result: MusicBrainzRecording): PlayRecord => {
 export default function Submit() {
   const router = useRouter();
   const agent = useStore((state) => state.pdsAgent);
+  const popfeedSyncEnabled = useStore((state) => state.popfeedSyncEnabled);
   const ctx = useContext(StampContext);
   const { state, setState } = ctx as StampContextValue;
 
@@ -261,6 +263,20 @@ powered by @teal.fm`;
         playRecord: record,
         blueskyPostUrl: null,
       };
+      if (popfeedSyncEnabled && agent) {
+        try {
+          await syncPlayToPopfeed(agent, {
+            play: record,
+            releaseDate: selectedTrack.selectedRelease?.date,
+            releaseGroupType:
+              selectedTrack.selectedRelease?.["release-group"]?.[
+                "primary-type"
+              ],
+          });
+        } catch (error) {
+          console.error("Failed to sync play to Popfeed:", error);
+        }
+      }
       if (shareWithBluesky && agent) {
         // lol this type
         const rt = new RichText({
diff --git a/apps/amethyst/app/(tabs)/settings/index.tsx b/apps/amethyst/app/(tabs)/settings/index.tsx
index 25e645e..0eeace1 100644
--- a/apps/amethyst/app/(tabs)/settings/index.tsx
+++ b/apps/amethyst/app/(tabs)/settings/index.tsx
@@ -17,6 +17,10 @@ export default function Settings() {
   const { colorScheme, setColorScheme } = useColorScheme();
   const appviewDid = useStore((state) => state.tealDid);
   const setAppviewDid = useStore((state) => state.setTealDid);
+  const popfeedSyncEnabled = useStore((state) => state.popfeedSyncEnabled);
+  const setPopfeedSyncEnabled = useStore(
+    (state) => state.setPopfeedSyncEnabled,
+  );
 
   const colorSchemeOptions = [
     { label: "Light", value: "light" },
@@ -47,6 +51,11 @@ export default function Settings() {
           onSubmit={(e) => setAppviewDid(e)}
           placeholder="Enter your Appview DID (e.g., did:web:...)"
         />
+        <ToggleSwitch
+          text="Sync first listens to Popfeed"
+          isEnabled={popfeedSyncEnabled}
+          setIsEnabled={setPopfeedSyncEnabled}
+        />
         <Link href="/auth/logoutModal" asChild>
           <Button variant="destructive" size="sm" className="w-max pb-1">
             <Text>Sign out</Text>
@@ -78,15 +87,16 @@ function ToggleSwitch({
 }: {
   text: string;
   isEnabled: boolean;
-  setIsEnabled: React.Dispatch<React.SetStateAction<boolean>>;
+  setIsEnabled: (enabled: boolean) => void;
 }) {
-  const toggleSwitch = () =>
-    setIsEnabled((previousState: boolean) => !previousState);
-
   return (
     <View className="flex-row items-center justify-between">
       <Text className="text-lg">{text}</Text>
-      <Switch className="ml-4" value={isEnabled} onValueChange={toggleSwitch} />
+      <Switch
+        className="ml-4"
+        value={isEnabled}
+        onValueChange={setIsEnabled}
+      />
     </View>
   );
 }
diff --git a/apps/amethyst/lib/__tests__/popfeed.test.ts b/apps/amethyst/lib/__tests__/popfeed.test.ts
new file mode 100644
index 0000000..d217f6e
--- /dev/null
+++ b/apps/amethyst/lib/__tests__/popfeed.test.ts
@@ -0,0 +1,156 @@
+import {
+  createPopfeedListRecord,
+  popfeedItemsFromPlay,
+  POPFEED_LIST_COLLECTION,
+  POPFEED_LIST_ITEM_COLLECTION,
+  syncPlayToPopfeed,
+  TEAL_POPFEED_LIST_NAME,
+} from "../popfeed";
+
+import type { Record as PlayRecord } from "@teal/lexicons/src/types/fm/teal/alpha/feed/play";
+
+describe("Popfeed sync mapping", () => {
+  const play: PlayRecord = {
+    trackName: "Age of Consent",
+    recordingMbId: "mbid:recording-1",
+    releaseName: "Power, Corruption & Lies",
+    releaseMbId: "mbid:release-1",
+    artists: [{ artistName: "New Order", artistMbId: "artist-1" }],
+    playedTime: "1983-05-02T12:00:00.000Z",
+  };
+
+  it("creates a Teal Popfeed list record", () => {
+    const record = createPopfeedListRecord(
+      new Date("2026-06-15T00:00:00.000Z"),
+    );
+
+    expect(record).toEqual({
+      $type: POPFEED_LIST_COLLECTION,
+      name: TEAL_POPFEED_LIST_NAME,
+      description: "Music first heard through Teal.",
+      listType: "default",
+      ordered: false,
+      itemOrder: [],
+      createdAt: "2026-06-15T00:00:00.000Z",
+    });
+  });
+
+  it("maps a played track to Popfeed track and album items", () => {
+    const items = popfeedItemsFromPlay({
+      play,
+      releaseDate: "1983-05-02",
+      releaseGroupType: "Album",
+    });
+
+    expect(items).toHaveLength(2);
+    expect(items[0]).toMatchObject({
+      $type: POPFEED_LIST_ITEM_COLLECTION,
+      addedAt: "1983-05-02T12:00:00.000Z",
+      creativeWorkType: "track",
+      identifiers: {
+        mbReleaseId: "recording-1",
+        parentMbReleaseId: "release-1",
+      },
+      listType: "default",
+      mainCredit: "New Order",
+      mainCreditRole: "artist",
+      releaseDate: "1983-05-02T00:00:00.000Z",
+      title: "Age of Consent",
+    });
+    expect(items[1]).toMatchObject({
+      $type: POPFEED_LIST_ITEM_COLLECTION,
+      creativeWorkType: "album",
+      identifiers: {
+        mbId: "release-1",
+        mbReleaseId: "release-1",
+      },
+      title: "Power, Corruption & Lies",
+    });
+  });
+
+  it("uses the EP creative work type for EP release groups", () => {
+    const items = popfeedItemsFromPlay({
+      play,
+      releaseGroupType: "EP",
+    });
+
+    expect(items[1].creativeWorkType).toBe("ep");
+  });
+
+  it("creates missing list items and skips duplicates", async () => {
+    const created: Record<string, unknown>[] = [];
+    const fakeAgent = {
+      did: "did:plc:viewer",
+      call: jest.fn(
+        async (
+          method: string,
+          params?: Record<string, unknown>,
+          data?: Record<string, unknown>,
+        ) => {
+          if (method === "com.atproto.repo.listRecords") {
+            if (params?.collection === POPFEED_LIST_COLLECTION) {
+              return {
+                data: {
+                  records: [
+                    {
+                      uri: "at://did:plc:viewer/social.popfeed.feed.list/abc",
+                      value: createPopfeedListRecord(),
+                    },
+                  ],
+                },
+              };
+            }
+            if (params?.collection === POPFEED_LIST_ITEM_COLLECTION) {
+              return {
+                data: {
+                  records: [
+                    {
+                      uri: "at://did:plc:viewer/social.popfeed.feed.listItem/track",
+                      value: {
+                        $type: POPFEED_LIST_ITEM_COLLECTION,
+                        addedAt: play.playedTime,
+                        creativeWorkType: "track",
+                        identifiers: { mbReleaseId: "recording-1" },
+                        listUri:
+                          "at://did:plc:viewer/social.popfeed.feed.list/abc",
+                      },
+                    },
+                  ],
+                },
+              };
+            }
+          }
+
+          if (method === "com.atproto.repo.createRecord") {
+            created.push(data?.record as Record<string, unknown>);
+            return {
+              data: {
+                uri: `at://did:plc:viewer/${data?.collection as string}/created`,
+              },
+            };
+          }
+
+          throw new Error(`Unexpected method ${method}`);
+        },
+      ),
+    };
+
+    const result = await syncPlayToPopfeed(fakeAgent, { play });
+
+    expect(result).toEqual({
+      created: 1,
+      skipped: 1,
+      listUri: "at://did:plc:viewer/social.popfeed.feed.list/abc",
+    });
+    expect(created).toHaveLength(1);
+    expect(created[0]).toMatchObject({
+      $type: POPFEED_LIST_ITEM_COLLECTION,
+      creativeWorkType: "album",
+      identifiers: {
+        mbId: "release-1",
+        mbReleaseId: "release-1",
+      },
+      listUri: "at://did:plc:viewer/social.popfeed.feed.list/abc",
+    });
+  });
+});
diff --git a/apps/amethyst/lib/popfeed.ts b/apps/amethyst/lib/popfeed.ts
new file mode 100644
index 0000000..f2ff629
--- /dev/null
+++ b/apps/amethyst/lib/popfeed.ts
@@ -0,0 +1,300 @@
+import type { Artist } from "@teal/lexicons/src/types/fm/teal/alpha/feed/defs";
+import type { Record as PlayRecord } from "@teal/lexicons/src/types/fm/teal/alpha/feed/play";
+
+export const POPFEED_LIST_COLLECTION = "social.popfeed.feed.list";
+export const POPFEED_LIST_ITEM_COLLECTION = "social.popfeed.feed.listItem";
+export const TEAL_POPFEED_LIST_NAME = "Teal listens";
+export const TEAL_POPFEED_LIST_TYPE = "default";
+
+type PopfeedIdentifiers = {
+  mbId?: string;
+  mbReleaseId?: string;
+  parentMbReleaseId?: string;
+};
+
+type PopfeedListRecord = {
+  $type: typeof POPFEED_LIST_COLLECTION;
+  name: string;
+  createdAt: string;
+  description?: string;
+  itemOrder?: string[];
+  listType?: string;
+  ordered?: boolean;
+};
+
+export type PopfeedListItemRecord = {
+  $type: typeof POPFEED_LIST_ITEM_COLLECTION;
+  addedAt: string;
+  creativeWorkType: "track" | "album" | "ep";
+  identifiers: PopfeedIdentifiers;
+  listUri: string;
+  backdropUrl?: string;
+  listType?: string;
+  mainCredit?: string;
+  mainCreditRole?: "artist";
+  posterUrl?: string;
+  releaseDate?: string;
+  title?: string;
+};
+
+type RepoListRecord = {
+  uri: string;
+  value?: unknown;
+};
+
+type PopfeedAgent = {
+  did?: string;
+  call: (
+    method: string,
+    params?: Record<string, unknown>,
+    data?: Record<string, unknown>,
+  ) => Promise<{ data: unknown }>;
+};
+
+export type PopfeedSyncInput = {
+  play: PlayRecord;
+  releaseDate?: string;
+  releaseGroupType?: string;
+};
+
+export type PopfeedSyncResult = {
+  created: number;
+  skipped: number;
+  listUri?: string;
+};
+
+function stripMbidPrefix(value?: string) {
+  return value?.replace(/^mbid:/, "");
+}
+
+function firstArtistName(artists?: Artist[]) {
+  return artists
+    ?.map((artist) => artist.artistName)
+    .find((artistName) => Boolean(artistName?.trim()))
+    ?.trim();
+}
+
+function optionalDateTime(value?: string) {
+  if (!value) return undefined;
+  const parsed = new Date(value);
+  if (Number.isNaN(parsed.getTime())) return undefined;
+  return parsed.toISOString();
+}
+
+function normalizeReleaseGroupType(value?: string): "album" | "ep" {
+  return value?.toLowerCase() === "ep" ? "ep" : "album";
+}
+
+function musicBrainzCoverArtUrl(releaseMbId?: string, size = 500) {
+  const mbid = stripMbidPrefix(releaseMbId);
+  return mbid
+    ? `https://coverartarchive.org/release/${mbid}/front-${size}`
+    : undefined;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+function isPopfeedListRecord(value: unknown): value is PopfeedListRecord {
+  return (
+    isRecord(value) &&
+    value.$type === POPFEED_LIST_COLLECTION &&
+    typeof value.name === "string"
+  );
+}
+
+function isPopfeedListItemRecord(
+  value: unknown,
+): value is PopfeedListItemRecord {
+  return (
+    isRecord(value) &&
+    value.$type === POPFEED_LIST_ITEM_COLLECTION &&
+    isRecord(value.identifiers)
+  );
+}
+
+function identifierMatches(a?: string, b?: string) {
+  const left = stripMbidPrefix(a);
+  const right = stripMbidPrefix(b);
+  return Boolean(left && right && left === right);
+}
+
+export function createPopfeedListRecord(now = new Date()): PopfeedListRecord {
+  return {
+    $type: POPFEED_LIST_COLLECTION,
+    name: TEAL_POPFEED_LIST_NAME,
+    description: "Music first heard through Teal.",
+    listType: TEAL_POPFEED_LIST_TYPE,
+    ordered: false,
+    itemOrder: [],
+    createdAt: now.toISOString(),
+  };
+}
+
+export function popfeedItemsFromPlay({
+  play,
+  releaseDate,
+  releaseGroupType,
+}: PopfeedSyncInput): PopfeedListItemRecord[] {
+  const addedAt = optionalDateTime(play.playedTime) ?? new Date().toISOString();
+  const artistName = firstArtistName(play.artists);
+  const recordingMbId = stripMbidPrefix(play.recordingMbId || play.trackMbId);
+  const releaseMbId = stripMbidPrefix(play.releaseMbId);
+  const releaseArt = musicBrainzCoverArtUrl(releaseMbId, 500);
+  const shared = {
+    addedAt,
+    listType: TEAL_POPFEED_LIST_TYPE,
+    mainCredit: artistName,
+    mainCreditRole: artistName ? ("artist" as const) : undefined,
+    posterUrl: releaseArt,
+    backdropUrl: releaseArt,
+    releaseDate: optionalDateTime(releaseDate),
+  };
+
+  const items: PopfeedListItemRecord[] = [];
+  if (recordingMbId) {
+    items.push({
+      ...shared,
+      $type: POPFEED_LIST_ITEM_COLLECTION,
+      creativeWorkType: "track",
+      identifiers: {
+        mbReleaseId: recordingMbId,
+        parentMbReleaseId: releaseMbId,
+      },
+      listUri: "",
+      title: play.trackName,
+    });
+  }
+
+  if (releaseMbId && play.releaseName) {
+    items.push({
+      ...shared,
+      $type: POPFEED_LIST_ITEM_COLLECTION,
+      creativeWorkType: normalizeReleaseGroupType(releaseGroupType),
+      identifiers: {
+        mbId: releaseMbId,
+        mbReleaseId: releaseMbId,
+      },
+      listUri: "",
+      title: play.releaseName,
+    });
+  }
+
+  return items;
+}
+
+function popfeedItemExists(
+  existingItems: PopfeedListItemRecord[],
+  nextItem: PopfeedListItemRecord,
+) {
+  return existingItems.some((existing) => {
+    if (existing.creativeWorkType !== nextItem.creativeWorkType) return false;
+    if (
+      identifierMatches(
+        existing.identifiers.mbReleaseId,
+        nextItem.identifiers.mbReleaseId,
+      )
+    ) {
+      return true;
+    }
+    return identifierMatches(existing.identifiers.mbId, nextItem.identifiers.mbId);
+  });
+}
+
+async function listAllRecords(
+  agent: PopfeedAgent,
+  repo: string,
+  collection: string,
+): Promise<RepoListRecord[]> {
+  const records: RepoListRecord[] = [];
+  let cursor: string | undefined;
+
+  do {
+    const response = await agent.call(
+      "com.atproto.repo.listRecords",
+      {
+        repo,
+        collection,
+        cursor,
+        limit: 100,
+      },
+      {},
+    );
+    const data = response.data as {
+      cursor?: string;
+      records?: RepoListRecord[];
+    };
+    records.push(...(data.records ?? []));
+    cursor = data.cursor;
+  } while (cursor);
+
+  return records;
+}
+
+async function ensurePopfeedList(agent: PopfeedAgent, did: string) {
+  const lists = await listAllRecords(agent, did, POPFEED_LIST_COLLECTION);
+  const existing = lists.find((record) => {
+    if (!isPopfeedListRecord(record.value)) return false;
+    return (
+      record.value.name === TEAL_POPFEED_LIST_NAME ||
+      record.value.listType === TEAL_POPFEED_LIST_TYPE
+    );
+  });
+  if (existing) return existing.uri;
+
+  const response = await agent.call(
+    "com.atproto.repo.createRecord",
+    {},
+    {
+      repo: did,
+      collection: POPFEED_LIST_COLLECTION,
+      record: createPopfeedListRecord(),
+    },
+  );
+  return (response.data as { uri: string }).uri;
+}
+
+export async function syncPlayToPopfeed(
+  agent: PopfeedAgent,
+  input: PopfeedSyncInput,
+): Promise<PopfeedSyncResult> {
+  if (!agent.did) {
+    throw new Error("Cannot sync to Popfeed without an authenticated DID.");
+  }
+
+  const listUri = await ensurePopfeedList(agent, agent.did);
+  const existingItems = (
+    await listAllRecords(agent, agent.did, POPFEED_LIST_ITEM_COLLECTION)
+  )
+    .map((record) => record.value)
+    .filter(isPopfeedListItemRecord);
+
+  const nextItems = popfeedItemsFromPlay(input).map((item) => ({
+    ...item,
+    listUri,
+  }));
+  let created = 0;
+  let skipped = 0;
+
+  for (const item of nextItems) {
+    if (popfeedItemExists(existingItems, item)) {
+      skipped += 1;
+      continue;
+    }
+
+    await agent.call(
+      "com.atproto.repo.createRecord",
+      {},
+      {
+        repo: agent.did,
+        collection: POPFEED_LIST_ITEM_COLLECTION,
+        record: item,
+      },
+    );
+    existingItems.push(item);
+    created += 1;
+  }
+
+  return { created, skipped, listUri };
+}
diff --git a/apps/amethyst/stores/preferenceSlice.tsx b/apps/amethyst/stores/preferenceSlice.tsx
index e5c006b..f8f1985 100644
--- a/apps/amethyst/stores/preferenceSlice.tsx
+++ b/apps/amethyst/stores/preferenceSlice.tsx
@@ -3,6 +3,8 @@ import { StateCreator } from "./mainStore";
 export interface PreferenceSlice {
   colorTheme: "dark" | "light" | "system";
   setColorTheme: (theme: "dark" | "light" | "system") => void;
+  popfeedSyncEnabled: boolean;
+  setPopfeedSyncEnabled: (enabled: boolean) => void;
   tealDid: string;
   setTealDid: (url: string) => void;
 }
@@ -11,6 +13,8 @@ export const createPreferenceSlice: StateCreator<PreferenceSlice> = (set) => {
   return {
     colorTheme: "system",
     setColorTheme: (theme) => set({ colorTheme: theme }),
+    popfeedSyncEnabled: false,
+    setPopfeedSyncEnabled: (enabled) => set({ popfeedSyncEnabled: enabled }),
     tealDid: process.env.EXPO_PUBLIC_DID_WEB ?? "did:web:rina.z.teal.fm",
     setTealDid: (url) => set({ tealDid: url }),
   };
diff --git a/todo.md b/todo.md
index 7c15367..01f866a 100644
--- a/todo.md
+++ b/todo.md
@@ -26,7 +26,7 @@ Last synced with GitHub and Linear issues: 2026-06-14.
   - Linear: `Backlog`, no priority
   - Create Popfeed records when a listener plays a track or album for the first time.
   - Consider follow-on flows for completing Popfeed reviews of songs and albums from Teal.
-  - Blocked locally: GitHub discussion says this should be a user-enabled sync, potentially with a later history backfill. Fresh lookup on 2026-06-15 found public usage of `social.popfeed.feed.listItem` and `social.popfeed.feed.list`, but `com.atproto.lexicon.resolveLexicon` is not implemented on the public appview and `popfeed.social`'s PDS has no `com.atproto.lexicon.schema` records for those NSIDs. Example records show fields like `title`, `mainCredit`, `mainCreditRole`, `creativeWorkType`, `identifiers`, `listUri`, `addedAt`, `posterUrl`, and `releaseDate`, but Teal still needs an authoritative Popfeed schema/auth contract before writing user records.
+  - Partial implementation: Amethyst settings now has a persisted opt-in toggle, and manual scrobble submission uses the published `bookhive.buzz` `social.popfeed.feed.list` / `social.popfeed.feed.listItem` lexicons to reuse an existing default Popfeed list or create `Teal listens`, then add first-seen track and album/EP list items with MusicBrainz identifiers. Focused tests cover the list, list item mapping, and duplicate-skip behavior. Remaining QA requires an authenticated submit with the toggle enabled, and the product/backend follow-up is deciding whether Cadet or another background path should also sync first listens from non-manual ingestion plus later history backfill.
 - [x] [#57](https://github.com/teal-fm/teal/issues/57) / [TEAL-30](https://linear.app/tealfm/issue/TEAL-30/top-albums-around-profile-pic) top albums around profile pic
   - Linear: `In Progress`, low priority
   - Labels: `API`, `Frontend`, `Legacy Songish Feature`
-- 
knotmirror 0.0.1