commit 3b9ab0a4ed998743f147100b95a872463bfafb06 · juli.ee/cleanfollow

+88 -88

src/App.tsx

···

       4
        
       import styles from "./App.module.css";

     

       5
        
       import { BskyAgent } from "@atproto/api";

     

       6
        
       

     

       7
       -
       type Form = {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       8
        
         handle: string;

     

       9
       -
         password: string;

     

       0
        
       
     

       0
        
       
     

       10
        
       };

     

       11
        
       

     

       12
        
       let [notices, setNotices] = createSignal<string[]>([], { equals: false });

     

       13
        
       let [progress, setProgress] = createSignal(0);

     

       14
        
       let [followCount, setFollowCount] = createSignal(0);

     

       15
       -
       let followRecords: Record<

     

       16
       -
         string,

     

       17
       -
         { handle: string; uri: string; toBeDeleted: boolean }

     

       18
       -
       > = {};

     

       19
        
       

     

       20
        
       const fetchFollows = async (agent: any) => {

     

       21
        
         const PAGE_LIMIT = 100;

     
···

       75
        
         });

     

       76
        
       };

     

       77
        
       

     

       78
       -
       const unfollowBsky = async (form: Form, preview: boolean) => {

     

       79
        
         setNotices([]);

     

       80
        
       

     

       81
       -
         const serviceURL = await fetchServiceEndpoint(form.handle);

     

       82
        
       

     

       83
        
         const agent = new BskyAgent({

     

       84
        
           service: serviceURL,

     
···

       86
        
       

     

       87
        
         try {

     

       88
        
           await agent.login({

     

       89
       -
             identifier: form.handle,

     

       90
       -
             password: form.password,

     

       91
        
           });

     

       92
        
         } catch (e: any) {

     

       93
        
           updateNotices(e.message);

     

       94
        
           return;

     

       95
        
         }

     

       96
        
       

     

       97
       -
         if (Object.keys(followRecords).length == 0 || preview) {

     

       98
       -
           if (preview) followRecords = {};

     

       99
       -
       

     

       100
        
           await fetchFollows(agent).then((follows) =>

     

       101
        
             follows.forEach((record: any) => {

     

       102
       -
               followRecords[record.value.subject] = {

     

       0
        
       
     

       103
        
                 handle: "",

     

       104
        
                 uri: record.uri,

     

       0
        
       
     

       105
        
                 toBeDeleted: false,

     

       106
       -
               };

     

       107
        
             }),

     

       108
        
           );

     

       109
        
       

     

       110
        
           setProgress(0);

     

       111
       -
           setFollowCount(Object.keys(followRecords).length);

     

       112
        
       

     

       113
       -
           Object.keys(followRecords).forEach(async (did) => {

     

       114
        
             try {

     

       115
       -
               const res = await agent.getProfile({ actor: did });

     

       116
        
               if (res.data.viewer?.blockedBy) {

     

       117
       -
                 followRecords[did].handle = res.data.handle;

     

       118
       -
                 followRecords[did].toBeDeleted = true;

     

       119
       -
                 updateNotices(

     

       120
       -
                   `Found account you are blocked by: ${did} (${res.data.handle})`,

     

       121
       -
                 );

     

       122
        
               }

     

       123
        
             } catch (e: any) {

     

       124
       -
               console.log(e.message);

     

       125
        
               const res = await fetch(

     

       126
       -
                 did.startsWith("did:web")

     

       127
       -
                   ? "https://" + did.split(":")[2] + "/.well-known/did.json"

     

       128
       -
                   : "https://plc.directory/" + did,

     

       129
        
               );

     

       130
        
       

     

       131
       -
               followRecords[did].handle = await res.json().then((doc) => {

     

       132
       -
                 for (const alias of doc.alsoKnownAs) {

     

       133
       -
                   if (alias.includes("at://")) {

     

       134
       -
                     return alias.split("//")[1];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       135
        
                   }

     

       136
       -
                 }

     

       137
       -
               });

     

       138
        
       

     

       139
        
               if (e.message.includes("not found")) {

     

       140
       -
                 followRecords[did].toBeDeleted = true;

     

       141
       -
                 updateNotices(

     

       142
       -
                   `Found deleted account: ${did} (${followRecords[did].handle})`,

     

       143
       -
                 );

     

       144
        
               } else if (e.message.includes("deactivated")) {

     

       145
       -
                 followRecords[did].toBeDeleted = true;

     

       146
       -
                 updateNotices(

     

       147
       -
                   `Found deactivated account: ${did} (${followRecords[did].handle})`,

     

       148
       -
                 );

     

       149
        
               } else if (e.message.includes("suspended")) {

     

       150
       -
                 followRecords[did].toBeDeleted = true;

     

       151
       -
                 updateNotices(

     

       152
       -
                   `Found suspended account: ${did} (${followRecords[did].handle})`,

     

       153
       -
                 );

     

       154
        
               }

     

       155
        
             }

     

       156
        
             setProgress(progress() + 1);

     

       157
        
           });

     

       158
        
         }

     

       159
        
       

     

       160
       -
         if (!preview) {

     

       161
       -
           setFollowCount(0);

     

       162
       -
       

     

       163
       -
           const unfollowCount = Object.values(followRecords).filter(

     

       164
       -
             (record) => record.toBeDeleted,

     

       165
       -
           ).length;

     

       166
       -
       

     

       167
       -
           const writes = Object.values(followRecords)

     

       168
       -
             .filter((record) => record.toBeDeleted)

     

       169
       -
             .map((record) => {

     

       170
       -
               return {

     

       171
       -
                 $type: "com.atproto.repo.applyWrites#delete",

     

       172
       -
                 collection: "app.bsky.graph.follow",

     

       173
       -
                 rkey: record.uri.split("/").pop(),

     

       174
       -
               };

     

       175
       -
             });

     

       176
       -
       

     

       177
       -
           const BATCHSIZE = 200;

     

       178
       -
           if (agent.session) {

     

       179
       -
             for (let i = 0; i < writes.length; i += BATCHSIZE) {

     

       180
       -
               await agent.com.atproto.repo.applyWrites({

     

       181
       -
                 repo: agent.session.did,

     

       182
       -
                 writes: writes.slice(i, i + BATCHSIZE),

     

       183
       -
               });

     

       184
       -
             }

     

       185
       -
           }

     

       186
       -
       

     

       187
       -
           setNotices([`Unfollowed ${unfollowCount} accounts.`]);

     

       188
       -
           followRecords = {};

     

       189
       -
         }

     

       190
        
       };

     

       191
        
       

     

       192
       -
       const UnfollowForm: Component = () => {

     

       193
       -
         const [formStore, setFormStore] = createStore<Form>({

     

       194
       -
           handle: "",

     

       195
       -
           password: "",

     

       196
       -
         });

     

       197
        
       

     

       198
        
         return (

     

       199
        
           <div>

     
···

       201
        
               <input

     

       202
        
                 type="text"

     

       203
        
                 placeholder="Handle"

     

       204
       -
                 onInput={(e) => setFormStore("handle", e.currentTarget.value)}

     

       205
        
               />

     

       206
        
             </div>

     

       207
        
             <div>

     

       208
        
               <input

     

       209
        
                 type="password"

     

       210
        
                 placeholder="App Password"

     

       211
       -
                 onInput={(e) => setFormStore("password", e.currentTarget.value)}

     

       212
        
               />

     

       213
        
             </div>

     

       214
       -
             <button type="button" onclick={() => unfollowBsky(formStore, true)}>

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       215
        
               Preview

     

       216
       -
             </button>

     

       217
       -
             <button type="button" onclick={() => unfollowBsky(formStore, false)}>

     

       218
       -
               Unfollow

     

       219
        
             </button>

     

       220
        
           </div>

     

       221
        
         );

     
···

       226
        
           <div class={styles.App}>

     

       227
        
             <h1>cleanfollow-bsky</h1>

     

       228
        
             <div class={styles.Warning}>

     

       229
       -
               <p>Unfollows all blocked by, deleted, and deactivated accounts</p>

     

       0
        
       
     

       0
        
       
     

       230
        
               <a href="https://github.com/notjuliet/cleanfollow-bsky">Source Code</a>

     

       231
        
             </div>

     

       232
       -
             <UnfollowForm />

     

       233
        
             <Show when={followCount()}>

     

       234
        
               <div>

     

       235
        
                 Progress: {progress()}/{followCount()}

···

       4
        
       import styles from "./App.module.css";

     

       5
        
       import { BskyAgent } from "@atproto/api";

     

       6
        
       

     

       7
       +
       enum RepoStatus {

     

       8
       +
         ACTIVE,

     

       9
       +
         BLOCKEDBY,

     

       10
       +
         DELETED,

     

       11
       +
         DEACTIVATED,

     

       12
       +
         SUSPENDED,

     

       13
       +
       }

     

       14
       +
       

     

       15
       +
       type FollowRecord = {

     

       16
       +
         did: string;

     

       17
        
         handle: string;

     

       18
       +
         uri: string;

     

       19
       +
         status: RepoStatus;

     

       20
       +
         toBeDeleted: boolean;

     

       21
        
       };

     

       22
        
       

     

       23
        
       let [notices, setNotices] = createSignal<string[]>([], { equals: false });

     

       24
        
       let [progress, setProgress] = createSignal(0);

     

       25
        
       let [followCount, setFollowCount] = createSignal(0);

     

       26
       +
       let [followRecords, setFollowRecords] = createStore<FollowRecord[]>([]);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       27
        
       

     

       28
        
       const fetchFollows = async (agent: any) => {

     

       29
        
         const PAGE_LIMIT = 100;

     
···

       83
        
         });

     

       84
        
       };

     

       85
        
       

     

       86
       +
       const fetchHiddenAccounts = async (handle: string, password: string) => {

     

       87
        
         setNotices([]);

     

       88
        
       

     

       89
       +
         const serviceURL = await fetchServiceEndpoint(handle);

     

       90
        
       

     

       91
        
         const agent = new BskyAgent({

     

       92
        
           service: serviceURL,

     
···

       94
        
       

     

       95
        
         try {

     

       96
        
           await agent.login({

     

       97
       +
             identifier: handle,

     

       98
       +
             password: password,

     

       99
        
           });

     

       100
        
         } catch (e: any) {

     

       101
        
           updateNotices(e.message);

     

       102
        
           return;

     

       103
        
         }

     

       104
        
       

     

       105
       +
         // handle rechecks

     

       106
       +
         if (followRecords.length == 0) {

     

       0
        
       
     

       107
        
           await fetchFollows(agent).then((follows) =>

     

       108
        
             follows.forEach((record: any) => {

     

       109
       +
               setFollowRecords(followRecords.length, {

     

       110
       +
                 did: record.value.subject,

     

       111
        
                 handle: "",

     

       112
        
                 uri: record.uri,

     

       113
       +
                 status: RepoStatus.ACTIVE,

     

       114
        
                 toBeDeleted: false,

     

       115
       +
               });

     

       116
        
             }),

     

       117
        
           );

     

       118
        
       

     

       119
        
           setProgress(0);

     

       120
       +
           setFollowCount(followRecords.length);

     

       121
        
       

     

       122
       +
           followRecords.forEach(async (record, index) => {

     

       123
        
             try {

     

       124
       +
               const res = await agent.getProfile({ actor: record.did });

     

       125
        
               if (res.data.viewer?.blockedBy) {

     

       126
       +
                 setFollowRecords(index, "handle", res.data.handle);

     

       127
       +
                 setFollowRecords(index, "status", RepoStatus.BLOCKEDBY);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       128
        
               }

     

       129
        
             } catch (e: any) {

     

       0
        
       
     

       130
        
               const res = await fetch(

     

       131
       +
                 record.did.startsWith("did:web")

     

       132
       +
                   ? "https://" + record.did.split(":")[2] + "/.well-known/did.json"

     

       133
       +
                   : "https://plc.directory/" + record.did,

     

       134
        
               );

     

       135
        
       

     

       136
       +
               setFollowRecords(

     

       137
       +
                 index,

     

       138
       +
                 "handle",

     

       139
       +
                 await res.json().then((doc) => {

     

       140
       +
                   for (const alias of doc.alsoKnownAs) {

     

       141
       +
                     if (alias.includes("at://")) {

     

       142
       +
                       return alias.split("//")[1];

     

       143
       +
                     }

     

       144
        
                   }

     

       145
       +
                 }),

     

       146
       +
               );

     

       147
        
       

     

       148
        
               if (e.message.includes("not found")) {

     

       149
       +
                 setFollowRecords(index, "status", RepoStatus.DELETED);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       150
        
               } else if (e.message.includes("deactivated")) {

     

       151
       +
                 setFollowRecords(index, "status", RepoStatus.DEACTIVATED);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       152
        
               } else if (e.message.includes("suspended")) {

     

       153
       +
                 setFollowRecords(index, "status", RepoStatus.SUSPENDED);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       154
        
               }

     

       155
        
             }

     

       156
        
             setProgress(progress() + 1);

     

       157
        
           });

     

       158
        
         }

     

       159
        
       

     

       160
       +
         //if (!preview) {

     

       161
       +
         //  setFollowCount(0);

     

       162
       +
         //

     

       163
       +
         //  const unfollowCount = Object.values(followRecords).filter(

     

       164
       +
         //    (record) => record.toBeDeleted,

     

       165
       +
         //  ).length;

     

       166
       +
         //

     

       167
       +
         //  const writes = Object.values(followRecords)

     

       168
       +
         //    .filter((record) => record.toBeDeleted)

     

       169
       +
         //    .map((record) => {

     

       170
       +
         //      return {

     

       171
       +
         //        $type: "com.atproto.repo.applyWrites#delete",

     

       172
       +
         //        collection: "app.bsky.graph.follow",

     

       173
       +
         //        rkey: record.uri.split("/").pop(),

     

       174
       +
         //      };

     

       175
       +
         //    });

     

       176
       +
         //

     

       177
       +
         //  const BATCHSIZE = 200;

     

       178
       +
         //  if (agent.session) {

     

       179
       +
         //    for (let i = 0; i < writes.length; i += BATCHSIZE) {

     

       180
       +
         //      await agent.com.atproto.repo.applyWrites({

     

       181
       +
         //        repo: agent.session.did,

     

       182
       +
         //        writes: writes.slice(i, i + BATCHSIZE),

     

       183
       +
         //      });

     

       184
       +
         //    }

     

       185
       +
         //  }

     

       186
       +
         //

     

       187
       +
         //  setNotices([`Unfollowed ${unfollowCount} accounts.`]);

     

       188
       +
         //  followRecords = {};

     

       189
       +
         //}

     

       190
        
       };

     

       191
        
       

     

       192
       +
       const Form: Component = () => {

     

       193
       +
         const [handle, setHandle] = createSignal("");

     

       194
       +
         const [password, setPassword] = createSignal("");

     

       0
        
       
     

       0
        
       
     

       195
        
       

     

       196
        
         return (

     

       197
        
           <div>

     
···

       199
        
               <input

     

       200
        
                 type="text"

     

       201
        
                 placeholder="Handle"

     

       202
       +
                 onInput={(e) => setHandle(e.currentTarget.value)}

     

       203
        
               />

     

       204
        
             </div>

     

       205
        
             <div>

     

       206
        
               <input

     

       207
        
                 type="password"

     

       208
        
                 placeholder="App Password"

     

       209
       +
                 onInput={(e) => setPassword(e.currentTarget.value)}

     

       210
        
               />

     

       211
        
             </div>

     

       212
       +
             <button

     

       213
       +
               type="button"

     

       214
       +
               onclick={() => fetchHiddenAccounts(handle(), password())}

     

       215
       +
             >

     

       216
        
               Preview

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       217
        
             </button>

     

       218
        
           </div>

     

       219
        
         );

     
···

       224
        
           <div class={styles.App}>

     

       225
        
             <h1>cleanfollow-bsky</h1>

     

       226
        
             <div class={styles.Warning}>

     

       227
       +
               <p>

     

       228
       +
                 Unfollows blocked by, deleted, suspended, and deactivated accounts

     

       229
       +
               </p>

     

       230
        
               <a href="https://github.com/notjuliet/cleanfollow-bsky">Source Code</a>

     

       231
        
             </div>

     

       232
       +
             <Form />

     

       233
        
             <Show when={followCount()}>

     

       234
        
               <div>

     

       235
        
                 Progress: {progress()}/{followCount()}