WIP

packages/backend/index.ts

···
 import { Worker } from 'bullmq'
 import expressWs from 'express-ws'
 import websocketRoutes from './routes/websocket.js'
-import followHashtagRoutes from './routes/followHashtags.js'
+import { followHashtagRoutes } from './routes/followHashtags.js'
 import { completeEnvironment } from './utils/backendOptions.js'
 import cron from 'node-cron'
 import { nukeBannedUsers } from './utils/maintenanceTasks/nukeBannedUsers.js'

packages/backend/migrations/2025.09.22T18.44.36.addBskyInviteCodeToUserForMigration.ts

···
+import { DataTypes, Sequelize } from 'sequelize'
+import { Migration } from '../migrate.js'
+import { FederatedHost } from '../models/federatedHost.js'
+
+export const up: Migration = async (params) => {
+  const queryInterface = params.context
+  await queryInterface.addColumn('users', 'bskyInviteCode', {
+    type: DataTypes.STRING,
+    defaultValue: '',
+    allowNull: true
+  })
+}
+export const down: Migration = async (params) => {
+  const queryInterface = params.context
+  await queryInterface.removeColumn('users', 'bskyInviteCode')
+}

packages/backend/models/user.ts

···
   emailVerified: Boolean | null
   selfDeleted: Boolean | null
   userMigratedTo: String | null
+  bskyInviteCode: String | null
 }
 
 @Table({
···
         'registerIp',
         'bskyAuthData',
         'bskyAppPassword',
-        'birthDate'
+        'birthDate',
+        'bskyInviteCode'
       ]
     }
   }
···
     type: DataType.STRING
   })
   declare followingCollectionUrl: string
+
+  @Column({
+    allowNull: true,
+    type: DataType.STRING
+  })
+  declare bskyInviteCode: string
 
   @Column({
     allowNull: true,
···
 
   // the username part of the handle, without the domain for both bsky and fedi
   get shortHandle() {
-    if (this.isBlueskyUser)
-      return this.url.split('@')[1].split('.')[0];
+    if (this.isBlueskyUser) return this.url.split('@')[1].split('.')[0]
 
-    if (this.isFediverseUser)
-      return this.url.split('@')[1]
+    if (this.isFediverseUser) return this.url.split('@')[1]
 
     return this.url
   }
 
   // the username part of the handle. For bluesky also includes the domain, but for fedi it doesn't
   get longHandle() {
-    if (this.isBlueskyUser || this.isFediverseUser)
-      return this.url.split('@')[1]
+    if (this.isBlueskyUser || this.isFediverseUser) return this.url.split('@')[1]
 
     return this.url
   }
···
   username: string
   handle: string
   domain: string
-  type: "fediverse" | "bluesky" | "local"
+  type: 'fediverse' | 'bluesky' | 'local'
 }
 
 export function splitHandle(handleString: string): HandleData {
···
         handle: handleString,
         username: username,
         domain: domain,
-        type: "fediverse"
+        type: 'fediverse'
       }
     } else if (userData.length === 2 && userData[0] == '') {
       const handle = userData[1]
···
         handle: handle,
         username: username,
         domain: domain,
-        type: "bluesky"
+        type: 'bluesky'
       }
     }
   }
···
     username: handleString,
     handle: handleString,
     domain: completeEnvironment.instanceUrl,
-    type: "local"
+    type: 'local'
   }
 }
 

packages/backend/routes/followHashtags.ts

···
 import { UserFollowHashtags } from '../models/userFollowHashtag.js'
 import { Queue } from 'bullmq'
 import { completeEnvironment } from '../utils/backendOptions.js'
+import { forceUpdateCacheDidsAtThread } from '../atproto/cache/getCacheAtDids.js'
 
-export default function followHashtagRoutes(app: Application) {
+function followHashtagRoutes(app: Application) {
   app.post('/api/followHashtag', authenticateToken, async (req: AuthorizedRequest, res: Response) => {
     let success = false
     if (req.body.hashtag && typeof req.body.hashtag === 'string') {
···
       })
     )
   })
+}
 
-  async function forceUpdateCacheDidsAtThread() {
-    const forceUpdaDidsteQueue = new Queue('forceUpdateDids', {
-      connection: completeEnvironment.bullmqConnection,
-      defaultJobOptions: {
-        removeOnComplete: true,
-        attempts: 3,
-        backoff: {
-          type: 'exponential',
-          delay: 1000
-        }
-      }
-    })
-    await forceUpdaDidsteQueue.add('forceUpdateDids', {})
-  }
-}
+export { followHashtagRoutes }

packages/backend/routes/users.ts

···
 import { completeEnvironment } from '../utils/backendOptions.js'
 import { sendUpdateProfile } from '../utils/activitypub/sendUpdateProfile.js'
 import axios from 'axios'
+import { getAtprotoUser } from '../atproto/utils/getAtprotoUser.js'
+import { getAllLocalUserIds } from '../utils/cacheGetters/getAllLocalUserIds.js'
+import { syncBskyFollowersAndFollowing } from '../utils/atproto/syncBskyFollowersAndFollowing.js'
 
 const markdownConverter = new showdown.Converter({
   simplifiedAutoLink: true,
···
             }
 
             const userWithEmail = User.create(user)
-            
+
             const instanceUrl = completeEnvironment.instanceUrl.startsWith('http')
               ? completeEnvironment.instanceUrl
               : `https://${completeEnvironment.instanceUrl}`
···
             } catch (err) {
               console.error('cannot use `completeEnvironment.instanceUrl` in `new URL` constructor')
             }
-            
+
             const email = req.body.email.toLowerCase()
             const activationLink = `${instanceUrl}/activate/${encodeURIComponent(email)}/${activationCode}`
             const mailHeader = `Welcome to ${instanceHost}, please verify your email!`
···
     }
   })
 
+  app.get('/api/get-bsky-invite-code', authenticateToken, async (req: AuthorizedRequest, res: Response) => {
+    if (!completeEnvironment.enableBsky) {
+      return res.status(500).send({
+        error: true,
+        message: `This instance does not have bluesky enabled at this moment`
+      })
+    }
+
+    const userId = req.jwtData?.userId as string
+
+    let user: User | null = null
+    try {
+      user = await User.scope('full').findByPk(userId)
+    } catch (error) {
+      logger.error({
+        message: `Error finding current user`,
+        error: error
+      })
+      return res.status(500).send({
+        error: true,
+        message: `Error finding current user`
+      })
+    }
+
+    if (!user) {
+      return res.status(404).send({
+        error: true,
+        message: `Current user not found in database`
+      })
+    }
+
+    if (user.bskyInviteCode) {
+      return res.send({ code: user.bskyInviteCode })
+    } else {
+      const authString = Buffer.from('admin:' + completeEnvironment.bskyPdsAdminPassword).toString('base64')
+      if (user.bskyDid) {
+        const deleteAccountReply = await axios.post(
+          'https://' + completeEnvironment.bskyPdsUrl + '/xrpc/com.atproto.admin.deleteAccount',
+          { did: user.bskyDid },
+          {
+            headers: {
+              'Content-Type': 'application/json',
+              Authorization: 'Basic ' + authString
+            }
+          }
+        )
+        user.bskyDid = ''
+        user.enableBsky = false
+        await user.save()
+      }
+      const inviteCodesReply: { code: string } = await axios.post(
+        'https://' + completeEnvironment.bskyPdsUrl + '/xrpc/com.atproto.server.createInviteCode',
+        { count: 1 },
+        {
+          headers: {
+            'Content-Type': 'application/json',
+            Authorization: 'Basic ' + authString
+          }
+        }
+      )
+      user.bskyInviteCode = inviteCodesReply.code
+      await user.save()
+      return res.send({ code: inviteCodesReply.code })
+    }
+  })
+
+  app.post('/api/connect-bsky-account', authenticateToken, async (req: AuthorizedRequest, res: Response) => {
+    if (!completeEnvironment.enableBsky) {
+      return res.status(500).send({
+        error: true,
+        message: `This instance does not have bluesky enabled at this moment`
+      })
+    }
+
+    const userId = req.jwtData?.userId as string
+    const user = await User.scope('full').findByPk(userId)
+    const bskyUrl = req.body.url
+    const pasword = req.body.password
+    if (user && bskyUrl && pasword) {
+      const localIds = await getAllLocalUserIds()
+      const bskyUser = await getAtprotoUser(bskyUrl, user)
+      if (bskyUser && bskyUser.bskyDid && !localIds.includes(bskyUser.id)) {
+        const serviceUrl = completeEnvironment.bskyPds.startsWith('http')
+          ? completeEnvironment.bskyPds
+          : 'https://' + completeEnvironment.bskyPds
+        const agent = new AtpAgent({
+          service: serviceUrl
+        })
+        const loginBskySuccess = (
+          await agent.sessionManager.login({
+            identifier: bskyUser.bskyDid as string,
+            password: pasword
+          })
+        ).success
+        if (loginBskySuccess) {
+          // ok now time to update stuff
+          const newDid = bskyUser.bskyDid
+          bskyUser.bskyDid = `INVALID_${bskyUser.bskyDid}`
+          await bskyUser.save()
+          user.bskyDid = newDid
+          user.enableBsky = true
+          user.bskyAppPassword = pasword
+          await user.save()
+          await Post.update(
+            {
+              userId: user.id
+            },
+            {
+              where: {
+                userId: bskyUser.id
+              }
+            }
+          )
+          await syncBskyFollowersAndFollowing(user.id)
+          await forceUpdateCacheDidsAtThread()
+        }
+      }
+    }
+  })
+
   app.get('/api/user/deleteFollow/:id', authenticateToken, async (req: AuthorizedRequest, res: Response) => {
     const userId = req.jwtData?.userId as string
     const forceUnfollowId = req.params?.id as string
···
   try {
     // the createAccount method will also login as the newly created user.
     const accountCreation = await agent.createAccount({
-      email: `${user.url}@${completeEnvironment.instanceUrl}`,
+      email: user.email as string,
       handle: `${sanitizedUrl}.${pdsHandleUrl}`,
       password,
       inviteCode