patch of MOOre features · round #0 · pull #1 · baileytownsend.dev/pds-moover

+93 -86

src/pdsmoover.js

···

       37
       37
        
           this.newAgent = null;

     

       38
       38
        
           this.missingBlobs = [];

     

       39
       39
        
           //State for reruns

     

       40
       40
       -
           this.oldAccountStatus = null;

     

       41
       41
       -
           this.newAccountStatus = null;

     

       42
       40
        
           this.createNewAccount = true;

     

       43
       41
        
           this.migrateRepo = true;

     

       44
       42
        
           this.migrateBlobs = true;

     
···

       90
       88
        
           safeStatusUpdate(statusUpdateHandler, 'Checking that the new PDS is an actual PDS (if the url is wrong this takes a while to error out)');

     

       91
       89
        
           const newAgent = new AtpAgent({service: newPdsUrl});

     

       92
       90
        
           const newHostDesc = await newAgent.com.atproto.server.describeServer();

     

       93
       93
       -
           const newHostWebDid = newHostDesc.data.did;

     

       91
       91
       +
           if (this.createNewAccount) {

     

       92
       92
       +
             const newHostWebDid = newHostDesc.data.did;

     

       94
       93
        
       

     

       95
       95
       -
           safeStatusUpdate(statusUpdateHandler, 'Creating a new account on the new PDS');

     

       94
       94
       +
             safeStatusUpdate(statusUpdateHandler, 'Creating a new account on the new PDS');

     

       96
       95
        
       

     

       97
       97
       -
           const createAuthResp = await oldAgent.com.atproto.server.getServiceAuth({

     

       98
       98
       -
             aud: newHostWebDid,

     

       99
       99
       -
             lxm: 'com.atproto.server.createAccount',

     

       100
       100
       -
           });

     

       101
       101
       -
           const serviceJwt = createAuthResp.data.token;

     

       96
       96
       +
             const createAuthResp = await oldAgent.com.atproto.server.getServiceAuth({

     

       97
       97
       +
               aud: newHostWebDid,

     

       98
       98
       +
               lxm: 'com.atproto.server.createAccount',

     

       99
       99
       +
             });

     

       100
       100
       +
             const serviceJwt = createAuthResp.data.token;

     

       102
       101
        
       

     

       103
       103
       -
           const createNewAccount = await newAgent.com.atproto.server.createAccount({

     

       104
       104
       -
             did: usersDid,

     

       105
       105
       -
             handle: newHandle,

     

       106
       106
       -
             email: newEmail,

     

       107
       107
       -
             password: password,

     

       108
       108
       -
             inviteCode: inviteCode,

     

       109
       109
       -
           },

     

       110
       110
       -
           {

     

       111
       111
       -
             headers: {authorization: `Bearer ${serviceJwt}`},

     

       112
       112
       -
             encoding: 'application/json',

     

       113
       113
       -
           });

     

       102
       102
       +
             const createNewAccount = await newAgent.com.atproto.server.createAccount({

     

       103
       103
       +
               did: usersDid,

     

       104
       104
       +
               handle: newHandle,

     

       105
       105
       +
               email: newEmail,

     

       106
       106
       +
               password: password,

     

       107
       107
       +
               inviteCode: inviteCode,

     

       108
       108
       +
             },

     

       109
       109
       +
             {

     

       110
       110
       +
               headers: {authorization: `Bearer ${serviceJwt}`},

     

       111
       111
       +
               encoding: 'application/json',

     

       112
       112
       +
             });

     

       114
       113
        
       

     

       115
       115
       -
           if (createNewAccount.data.did !== usersDid.toString()) {

     

       116
       116
       -
             throw new Error('Did not create the new account with the same did as the old account');

     

       114
       114
       +
             if (createNewAccount.data.did !== usersDid.toString()) {

     

       115
       115
       +
               throw new Error('Did not create the new account with the same did as the old account');

     

       116
       116
       +
             }

     

       117
       117
        
           }

     

       118
       118
       -
       

     

       119
       118
        
           safeStatusUpdate(statusUpdateHandler, 'Logging in with the new account');

     

       120
       119
        
       

     

       121
       120
        
           await newAgent.login({

     
···

       123
       122
        
             password: password,

     

       124
       123
        
           });

     

       125
       124
        
       

     

       126
       126
       -
           safeStatusUpdate(statusUpdateHandler, 'Migrating your repo');

     

       127
       127
       -
           const repoRes = await oldAgent.com.atproto.sync.getRepo({did: usersDid});

     

       128
       128
       -
           await newAgent.com.atproto.repo.importRepo(repoRes.data, {

     

       129
       129
       -
             encoding: 'application/vnd.ipld.car',

     

       130
       130
       -
           });

     

       125
       125
       +
           if (this.migrateRepo) {

     

       126
       126
       +
             safeStatusUpdate(statusUpdateHandler, 'Migrating your repo');

     

       127
       127
       +
             const repoRes = await oldAgent.com.atproto.sync.getRepo({did: usersDid});

     

       128
       128
       +
             await newAgent.com.atproto.repo.importRepo(repoRes.data, {

     

       129
       129
       +
               encoding: 'application/vnd.ipld.car',

     

       130
       130
       +
             });

     

       131
       131
       +
           }

     

       131
       132
        
       

     

       132
       133
        
           let newAccountStatus = await newAgent.com.atproto.server.checkAccountStatus();

     

       133
       133
       -
           safeStatusUpdate(statusUpdateHandler, 'Migrating your blobs');

     

       134
       134
       -
       

     

       135
       135
       -
           let blobCursor = undefined;

     

       136
       136
       -
           let uploadedBlobs = 0;

     

       137
       137
       -
           do {

     

       138
       138
       -
             safeStatusUpdate(statusUpdateHandler, `Migrating blobs: ${uploadedBlobs}/${newAccountStatus.data.expectedBlobs}`);

     

       139
       134
        
       

     

       140
       140
       -
             const listedBlobs = await oldAgent.com.atproto.sync.listBlobs({

     

       141
       141
       -
               did: usersDid,

     

       142
       142
       -
               cursor: blobCursor,

     

       143
       143
       -
               limit: 100,

     

       144
       144
       -
             });

     

       135
       135
       +
           if (this.migrateBlobs) {

     

       136
       136
       +
             safeStatusUpdate(statusUpdateHandler, 'Migrating your blobs');

     

       145
       137
        
       

     

       146
       146
       -
             for (const cid of listedBlobs.data.cids) {

     

       147
       147
       -
               try {

     

       148
       148
       -
                 //TODO may move the status update here but would have it only update like every 10

     

       149
       149
       -
                 const blobRes = await oldAgent.com.atproto.sync.getBlob({

     

       150
       150
       -
                   did: usersDid,

     

       151
       151
       -
                   cid,

     

       152
       152
       -
                 });

     

       153
       153
       -
                 await newAgent.com.atproto.repo.uploadBlob(blobRes.data, {

     

       154
       154
       -
                   encoding: blobRes.headers['content-type'],

     

       155
       155
       -
                 });

     

       156
       156
       -
                 uploadedBlobs++;

     

       157
       157
       -
                 if (uploadedBlobs % 10 === 0) {

     

       158
       158
       -
                   safeStatusUpdate(statusUpdateHandler, `Migrating blobs: ${uploadedBlobs}/${newAccountStatus.data.expectedBlobs}`);

     

       159
       159
       -
                 }

     

       160
       160
       -
               } catch (error) {

     

       161
       161
       -
                 //TODO silently logging for now will do a missing blobs later

     

       162
       162
       -
                 console.error(error);

     

       163
       163
       -
               }

     

       164
       164
       -
             }

     

       165
       165
       -
             blobCursor = listedBlobs.data.cursor;

     

       166
       166
       -
           } while (blobCursor);

     

       167
       167
       -
       

     

       168
       168
       -
           newAccountStatus = await newAgent.com.atproto.server.checkAccountStatus();

     

       169
       169
       -
           if (newAccountStatus.data.expectedBlobs !== uploadedBlobs) {

     

       170
       170
       -
             let totalMissingBlobs = newAccountStatus.data.expectedBlobs - uploadedBlobs;

     

       171
       171
       -
             safeStatusUpdate(statusUpdateHandler, 'Looks like there are some missing blobs. Going to try and upload them now.');

     

       172
       172
       -
             //Probably should be shared between main blob uploader, but eh

     

       173
       173
       -
             let missingBlobCursor = undefined;

     

       174
       174
       -
             let missingUploadedBlobs = 0;

     

       138
       138
       +
             let blobCursor = undefined;

     

       139
       139
       +
             let uploadedBlobs = 0;

     

       175
       140
        
             do {

     

       176
       176
       -
               safeStatusUpdate(statusUpdateHandler, `Migrating blobs: ${missingUploadedBlobs}/${totalMissingBlobs}`);

     

       141
       141
       +
               safeStatusUpdate(statusUpdateHandler, `Migrating blobs: ${uploadedBlobs}/${newAccountStatus.data.expectedBlobs}`);

     

       177
       142
        
       

     

       178
       178
       -
               const missingBlobs = await oldAgent.com.atproto.repo.listMissingBlobs({

     

       143
       143
       +
               const listedBlobs = await oldAgent.com.atproto.sync.listBlobs({

     

       179
       144
        
                 did: usersDid,

     

       180
       180
       -
                 cursor: missingBlobCursor,

     

       145
       145
       +
                 cursor: blobCursor,

     

       181
       146
        
                 limit: 100,

     

       182
       147
        
               });

     

       183
       148
        
       

     

       184
       184
       -
               for (const cid of missingBlobs.data.cids) {

     

       149
       149
       +
               for (const cid of listedBlobs.data.cids) {

     

       185
       150
        
                 try {

     

       186
       186
       -
                   //TODO may move the status update here but would have it only update like every 10

     

       187
       151
        
                   const blobRes = await oldAgent.com.atproto.sync.getBlob({

     

       152
       152
       +
                     did: usersDid,

     

       188
       153
        
                     cid,

     

       189
       154
        
                   });

     

       190
       155
        
                   await newAgent.com.atproto.repo.uploadBlob(blobRes.data, {

     

       191
       156
        
                     encoding: blobRes.headers['content-type'],

     

       192
       157
        
                   });

     

       158
       158
       +
                   uploadedBlobs++;

     

       193
       159
        
                   if (uploadedBlobs % 10 === 0) {

     

       194
       194
       -
                     safeStatusUpdate(statusUpdateHandler, `Migrating blobs: ${uploadedBlobs}/${uploadedBlobs}`);

     

       160
       160
       +
                     safeStatusUpdate(statusUpdateHandler, `Migrating blobs: ${uploadedBlobs}/${newAccountStatus.data.expectedBlobs}`);

     

       195
       161
        
                   }

     

       196
       196
       -
                   uploadedBlobs++;

     

       197
       162
        
                 } catch (error) {

     

       198
       198
       -
                   //TODO silently logging for now will do a missing blobs later

     

       199
       163
        
                   console.error(error);

     

       200
       200
       -
                   this.missingBlobs.push(cid);

     

       201
       164
        
                 }

     

       202
       165
        
               }

     

       203
       203
       -
               missingBlobCursor = missingBlobs.data.cursor;

     

       204
       204
       -
             } while (missingBlobCursor);

     

       205
       205
       -
       

     

       166
       166
       +
               blobCursor = listedBlobs.data.cursor;

     

       167
       167
       +
             } while (blobCursor);

     

       206
       168
        
           }

     

       207
       169
        
       

     

       208
       208
       -
           const prefs = await oldAgent.app.bsky.actor.getPreferences();

     

       209
       209
       -
           await newAgent.app.bsky.actor.putPreferences(prefs.data);

     

       210
       210
       -
           this.oldAgent = oldAgent;

     

       211
       211
       -
           this.newAgent = newAgent;

     

       212
       212
       -
           await oldAgent.com.atproto.identity.requestPlcOperationSignature();

     

       213
       213
       -
           safeStatusUpdate(statusUpdateHandler, 'Please check your email for a PLC token');

     

       170
       170
       +
           if (this.migrateMissingBlobs) {

     

       171
       171
       +
             newAccountStatus = await newAgent.com.atproto.server.checkAccountStatus();

     

       172
       172
       +
             if (newAccountStatus.data.expectedBlobs !== newAccountStatus.data.importedBlobs) {

     

       173
       173
       +
               let totalMissingBlobs = newAccountStatus.data.expectedBlobs - newAccountStatus.data.importedBlobs;

     

       174
       174
       +
               safeStatusUpdate(statusUpdateHandler, 'Looks like there are some missing blobs. Going to try and upload them now.');

     

       175
       175
       +
               //Probably should be shared between main blob uploader, but eh

     

       176
       176
       +
               let missingBlobCursor = undefined;

     

       177
       177
       +
               let missingUploadedBlobs = 0;

     

       178
       178
       +
               do {

     

       179
       179
       +
                 safeStatusUpdate(statusUpdateHandler, `Migrating blobs: ${missingUploadedBlobs}/${totalMissingBlobs}`);

     

       180
       180
       +
       

     

       181
       181
       +
                 const missingBlobs = await newAgent.com.atproto.repo.listMissingBlobs({

     

       182
       182
       +
                   cursor: missingBlobCursor,

     

       183
       183
       +
                   limit: 100,

     

       184
       184
       +
                 });

     

       214
       185
        
       

     

       186
       186
       +
                 for (const recordBlob of missingBlobs.data.blobs) {

     

       187
       187
       +
                   try {

     

       188
       188
       +
                     //TODO may move the status update here but would have it only update like every 10

     

       189
       189
       +
                     const blobRes = await oldAgent.com.atproto.sync.getBlob({

     

       190
       190
       +
                       did: usersDid,

     

       191
       191
       +
                       cid: recordBlob.cid,

     

       192
       192
       +
                     });

     

       193
       193
       +
                     await newAgent.com.atproto.repo.uploadBlob(blobRes.data, {

     

       194
       194
       +
                       encoding: blobRes.headers['content-type'],

     

       195
       195
       +
                     });

     

       196
       196
       +
                     if (missingUploadedBlobs % 10 === 0) {

     

       197
       197
       +
                       safeStatusUpdate(statusUpdateHandler, `Migrating blobs: ${missingUploadedBlobs}/${totalMissingBlobs}`);

     

       198
       198
       +
                     }

     

       199
       199
       +
                     missingUploadedBlobs++;

     

       200
       200
       +
                   } catch (error) {

     

       201
       201
       +
                     //TODO silently logging for now will do a missing blobs later

     

       202
       202
       +
                     console.error(error);

     

       203
       203
       +
                     this.missingBlobs.push(cid);

     

       204
       204
       +
                   }

     

       205
       205
       +
                 }

     

       206
       206
       +
                 missingBlobCursor = missingBlobs.data.cursor;

     

       207
       207
       +
               } while (missingBlobCursor);

     

       208
       208
       +
       

     

       209
       209
       +
             }

     

       210
       210
       +
           }

     

       211
       211
       +
           if (this.migratePrefs) {

     

       212
       212
       +
             const prefs = await oldAgent.app.bsky.actor.getPreferences();

     

       213
       213
       +
             await newAgent.app.bsky.actor.putPreferences(prefs.data);

     

       214
       214
       +
             this.oldAgent = oldAgent;

     

       215
       215
       +
             this.newAgent = newAgent;

     

       216
       216
       +
           }

     

       217
       217
       +
       

     

       218
       218
       +
           if (this.migratePlcRecord) {

     

       219
       219
       +
             await oldAgent.com.atproto.identity.requestPlcOperationSignature();

     

       220
       220
       +
             safeStatusUpdate(statusUpdateHandler, 'Please check your email for a PLC token');

     

       221
       221
       +
           }

     

       215
       222
        
         }

     

       216
       223
        
       

     

       217
       224
        
         async signPlcOperation(token) {

public/style.css

···

       17
       17
        
           font-weight: 500;

     

       18
       18
        
           color: #646cff;

     

       19
       19
        
           text-decoration: inherit;

     

       20
       20
       +
           text-decoration: underline;

     

       20
       21
        
       }

     

       21
       22
        
       

     

       22
       23
        
       a:hover {

+2 -2

README.md

···

       2
       2
        
       

     

       3
       3
        
       ![moo](./public/moo.webp)

     

       4
       4
        
       

     

       5
       5
       -
       Use at your own risk, I will not host till I have a bit more validation and retry logic in place.

     

       6
       6
       -
       AND it will still be very much so, use at your own Risk.
     

       5
       5
       +
       A no frills client side PDS account migrator for ATProto. For more info check out

     

       6
       6
       +
       [pdsmoover.com](https://pdsmoover.com)