feat: handle record deletion

src/entrypoints/background.ts

···
   frontersCache,
   parseSocialAppPostUrl,
   displayNameCache,
+  deleteFronter,
 } from "@/lib/utils";
 import {
   parseCanonicalResourceUri,
···
       browser.tabs.onUpdated.addListener(deleteOld);
     };
 
+    const handleDelete = async (
+      data: any,
+      authToken: string | null,
+      sender: globalThis.Browser.runtime.MessageSender,
+    ) => {
+      if (!authToken) return;
+      const deleted = await deleteFronter(
+        data.repo,
+        data.collection,
+        data.rkey,
+        authToken,
+      );
+      if (!deleted.ok) {
+        console.error("failed to delete fronter:", deleted.error);
+      }
+    };
     const handleWrite = async (
       items: any[],
       authToken: string | null,
···
       if (message.type !== "RESPONSE_CAPTURED") return;
       console.log("handling response", message.data);
       switch (message.data.type as string) {
+        case "delete":
+          await handleDelete(
+            JSON.parse(message.data.body),
+            message.data.authToken,
+            sender,
+          );
+          break;
         case "write":
           await handleWrite(
             JSON.parse(message.data.body).results,

src/entrypoints/content.ts

···
     const overriddenFetch = async (
       ...args: [input: RequestInfo | URL, init?: RequestInit]
     ) => {
+      const getRequestBody = async () => {
+        if (args[0] instanceof Request) {
+          if (args[0].bodyUsed) return null;
+          try {
+            const clone = args[0].clone();
+            return await clone.text();
+          } catch {
+            return null;
+          }
+        } else if (args[1]?.body) {
+          return typeof args[1].body === "string"
+            ? args[1].body
+            : JSON.stringify(args[1].body);
+        }
+        return null;
+      };
+      const requestBody = await getRequestBody();
       const response = await originalFetch.apply(this, args);
 
       if (respEventName === null) return response;
···
           authToken: getAuthToken(),
         };
       } else if (response.url.includes("/xrpc/com.atproto.repo.deleteRecord")) {
+        detail = {
+          type: "delete",
+          body: requestBody,
+          authToken: getAuthToken(),
+        };
       } else if (response.url.includes("/xrpc/com.atproto.repo.createRecord")) {
         detail = {
           type: "writeOne",

src/lib/utils.ts

···
   GenericUri,
   Handle,
   isHandle,
+  Nsid,
   RecordKey,
   type AtprotoDid,
   type ResourceUri,
···
     handle,
     members: filteredMembers,
   });
+};
+
+export const deleteFronter = async (
+  did: AtprotoDid,
+  collection: Nsid,
+  rkey: RecordKey,
+  authToken: string,
+): Promise<Result<boolean, string>> => {
+  // make client
+  const atpClient = await getAtpClient(did);
+
+  // delete
+  let maybeRecord = await atpClient.post("com.atproto.repo.deleteRecord", {
+    input: {
+      repo: did,
+      collection: fronterSchema.object.shape.$type.expected,
+      rkey: `${collection}_${rkey}`,
+    },
+    headers: { authorization: `Bearer ${authToken}` },
+  });
+  if (!maybeRecord.ok)
+    return err(maybeRecord.data.message ?? maybeRecord.data.error);
+
+  return ok(true);
 };
 
 export const getSpFronters = async (): Promise<MemberUri[]> => {