you can now follow on spark and tangled !!!!!! (ps it will duplicate follows that's a different thing i've to work on ok)

netlify/functions/batch-follow-users.ts

···
     // Parse request body
     const body = JSON.parse(event.body || "{}");
     const dids: string[] = body.dids || [];
+    const followLexicon: string = body.followLexicon || "app.bsky.graph.follow";
 
     if (!Array.isArray(dids) || dids.length === 0) {
       return {
···
       try {
         await agent.api.com.atproto.repo.createRecord({
           repo: userDid,
-          collection: "app.bsky.graph.follow",
+          collection: followLexicon,
           record: {
-            $type: "app.bsky.graph.follow",
+            $type: followLexicon,
             subject: did,
             createdAt: new Date().toISOString(),
           },

src/App.tsx

···
     totalFound,
   } = useSearch(session);
 
+  const currentDestinationAppId =
+    userSettings.platformDestinations[
+      currentPlatform as keyof UserSettings["platformDestinations"]
+    ];
+
   // Follow hook
   const { isFollowing, followSelectedUsers } = useFollow(
     session,
     searchResults,
     setSearchResults,
+    currentDestinationAppId,
   );
 
   // File upload hook

src/constants/atprotoApps.ts

···
     link: "https://bsky.app/",
     icon: "🦋",
     action: "Follow",
+    followLexicon: "app.bsky.graph.follow",
     enabled: true,
   },
   tangled: {
···
     link: "https://tangled.org/",
     icon: "🐑",
     action: "Follow",
-    enabled: false, // Not yet integrated
+    followLexicon: "sh.tangled.graph.follow",
+    enabled: true,
   },
   spark: {
     id: "spark",
···
     link: "https://sprk.so/",
     icon: "✨",
     action: "Follow",
-    enabled: false, // Not yet integrated
+    followLexicon: "so.sprk.graph.follow",
+    enabled: true,
   },
   lists: {
     id: "bsky list",
···
     link: "https://bsky.app/",
     icon: "📃",
     action: "Add to",
+    followLexicon: "app.bsky.graph.follow",
     enabled: false, // Not yet implemented
   },
 };

src/constants/platforms.ts

···
 import {
   Twitter,
   Instagram,
-  Video,
+  Github,
+  Youtube,
   Hash,
-  Gamepad2,
+  Twitch,
+  Video,
   LucideIcon,
 } from "lucide-react";
 
···
   },
   twitch: {
     name: "Twitch",
-    icon: Gamepad2,
+    icon: Twitch,
     color: "from-purple-600 to-purple-800",
     accentBg: "bg-purple-600",
     fileHint: "following.json or data export",
···
   },
   youtube: {
     name: "YouTube",
-    icon: Video,
+    icon: Youtube,
     color: "from-red-600 to-red-700",
     accentBg: "bg-red-600",
     fileHint: "subscriptions.csv or Takeout ZIP",
     enabled: false,
     defaultApp: "bluesky",
+  },
+  github: {
+    name: "Github",
+    icon: Github,
+    color: "from-red-600 to-red-700",
+    accentBg: "bg-red-600",
+    fileHint: "subscriptions.csv or Takeout ZIP",
+    enabled: false,
+    defaultApp: "tangled",
   },
 };
 

src/hooks/useFollows.ts

···
 import { useState } from "react";
 import { apiClient } from "../lib/apiClient";
 import { FOLLOW_CONFIG } from "../constants/platforms";
-import type { SearchResult, AtprotoSession } from "../types";
+import { ATPROTO_APPS } from "../constants/atprotoApps";
+import type { SearchResult, AtprotoSession, AtprotoAppId } from "../types";
 
 export function useFollow(
   session: AtprotoSession | null,
···
   setSearchResults: (
     results: SearchResult[] | ((prev: SearchResult[]) => SearchResult[]),
   ) => void,
+  destinationAppId: AtprotoAppId,
 ) {
   const [isFollowing, setIsFollowing] = useState(false);
 
···
   ): Promise<void> {
     if (!session || isFollowing) return;
 
+    // Determine source platform for results
+    const followLexicon = ATPROTO_APPS[destinationAppId]?.followLexicon;
+    const destinationName =
+      ATPROTO_APPS[destinationAppId]?.name || "Undefined App";
+
+    if (!followLexicon) {
+      onUpdate(
+        `Error: Invalid destination app or lexicon for ${destinationAppId}`,
+      );
+      return;
+    }
+
+    // Follow users
     const selectedUsers = searchResults.flatMap((result, resultIndex) =>
       result.atprotoMatches
         .filter((match) => result.selectedMatches?.has(match.did))
···
     }
 
     setIsFollowing(true);
-    onUpdate(`Following ${selectedUsers.length} users...`);
+    onUpdate(
+      `Following ${selectedUsers.length} users on ${destinationName}...`,
+    );
     let totalFollowed = 0;
     let totalFailed = 0;
 
···
         const dids = batch.map((user) => user.did);
 
         try {
-          const data = await apiClient.batchFollowUsers(dids);
+          const data = await apiClient.batchFollowUsers(dids, followLexicon);
           totalFollowed += data.succeeded;
           totalFailed += data.failed;
 

src/lib/apiClient/realApiClient.ts

···
   },
 
   // Follow Operations
-  async batchFollowUsers(dids: string[]): Promise<{
+  async batchFollowUsers(
+    dids: string[],
+    followLexicon: string,
+  ): Promise<{
     success: boolean;
     total: number;
     succeeded: number;
···
       method: "POST",
       credentials: "include",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ dids }),
+      body: JSON.stringify({ dids, followLexicon }),
     });
 
     if (!res.ok) {

src/types/settings.ts

···
   description: string;
   link: string;
   icon: string;
+  followLexicon: string;
   action: string;
   enabled: boolean;
 }