Move minecraft protocol into worker!

.eslintrc.json

@@ -199,7 +199,8 @@
         "no-bitwise": "off",
         "unicorn/filename-case": "off",
         "max-depth": "off",
-        "unicorn/no-typeof-undefined": "off"
+        "unicorn/no-typeof-undefined": "off",
+        "unicorn/relative-url-style": "off"
     },
     "overrides": [
         {

renderer/viewer/lib/simpleUtils.ts

@@ -33,3 +33,9 @@ export function sectionPos (pos: { x: number, y: number, z: number }) {
   const z = Math.floor(pos.z / 16)
   return [x, y, z]
 }
+// doesn't support snapshots
+
+export const toMajorVersion = version => {
+  const [a, b] = (String(version)).split('.')
+  return `${a}.${b}`
+}

renderer/viewer/lib/workerProxy.ts

@@ -1,9 +1,18 @@
-export function createWorkerProxy<T extends Record<string, (...args: any[]) => void>> (handlers: T, channel?: MessagePort): { __workerProxy: T } {
+export function createWorkerProxy<T extends Record<string, (...args: any[]) => void | Promise<any>>> (handlers: T, channel?: MessagePort): { __workerProxy: T } {
   const target = channel ?? globalThis
   target.addEventListener('message', (event: any) => {
-    const { type, args } = event.data
+    const { type, args, msgId } = event.data
     if (handlers[type]) {
-      handlers[type](...args)
+      const result = handlers[type](...args)
+      if (result instanceof Promise) {
+        void result.then((result) => {
+          target.postMessage({
+            type: 'result',
+            msgId,
+            args: [result]
+          })
+        })
+      }
     }
   })
   return null as any
@@ -23,6 +32,7 @@ export function createWorkerProxy<T extends Record<string, (...args: any[]) => v
 export const useWorkerProxy = <T extends { __workerProxy: Record<string, (...args: any[]) => void> }> (worker: Worker | MessagePort, autoTransfer = true): T['__workerProxy'] & {
   transfer: (...args: Transferable[]) => T['__workerProxy']
 } => {
+  let messageId = 0
   // in main thread
   return new Proxy({} as any, {
     get (target, prop) {
@@ -41,11 +51,25 @@ export const useWorkerProxy = <T extends { __workerProxy: Record<string, (...arg
         }
       }
       return (...args: any[]) => {
+        const msgId = messageId++
         const transfer = autoTransfer ? args.filter(arg => arg instanceof ArrayBuffer || arg instanceof MessagePort || arg instanceof ImageBitmap || arg instanceof OffscreenCanvas || arg instanceof ImageData) : []
         worker.postMessage({
           type: prop,
+          msgId,
           args,
         }, transfer as any[])
+        return {
+          // eslint-disable-next-line unicorn/no-thenable
+          then (onfulfilled: (value: any) => void) {
+            const handler = ({ data }: MessageEvent): void => {
+              if (data.type === 'result' && data.msgId === msgId) {
+                onfulfilled(data.args[0])
+                worker.removeEventListener('message', handler as EventListener)
+              }
+            }
+            worker.addEventListener('message', handler as EventListener)
+          }
+        }
       }
     }
   })

renderer/viewer/lib/worldrendererCommon.ts

@@ -9,13 +9,12 @@ import { WorldBlockProvider } from 'mc-assets/dist/worldBlockProvider'
 import { generateSpiralMatrix } from 'flying-squid/dist/utils'
 import { subscribeKey } from 'valtio/utils'
 import { dynamicMcDataFiles } from '../../buildMesherConfig.mjs'
-import { toMajorVersion } from '../../../src/utils'
 import { ResourcesManager } from '../../../src/resourcesManager'
 import { DisplayWorldOptions, GraphicsInitOptions, RendererReactiveState } from '../../../src/appViewer'
 import { SoundSystem } from '../three/threeJsSound'
 import { buildCleanupDecorator } from './cleanupDecorator'
 import { HighestBlockInfo, MesherGeometryOutput, CustomBlockModels, BlockStateModelInfo, getBlockAssetsCacheKey, MesherConfig } from './mesher/shared'
-import { chunkPos } from './simpleUtils'
+import { chunkPos, toMajorVersion } from './simpleUtils'
 import { addNewStat, removeAllStats, removeStat, updatePanesVisibility, updateStatText } from './ui/newStats'
 import { WorldDataEmitter } from './worldDataEmitter'
 import { IPlayerState } from './basePlayerState'

rsbuild.config.ts

@@ -225,7 +225,8 @@ const appConfig = defineConfig({
                             console.log('single file size', (fs.statSync(singleBuildHtml).size / 1024 / 1024).toFixed(2), 'mb')
                         } else {
                             if (!disableServiceWorker) {
-                            const { count, size, warnings } = await generateSW({
+                                patchWorkerImport()
+                                const { count, size, warnings } = await generateSW({
                                     // dontCacheBustURLsMatching: [new RegExp('...')],
                                     globDirectory: 'dist',
                                     skipWaiting: true,
@@ -254,3 +255,18 @@ export default mergeRsbuildConfig(
     appAndRendererSharedConfig(),
     appConfig
 )
+
+const patchWorkerImport = () => {
+    const workerFiles = fs.readdirSync('./dist/static/js/async').filter(x => x.endsWith('.js'))
+    let patched = false
+    for (const file of workerFiles) {
+        const filePath = `./dist/static/js/async/${file}`
+        const content = fs.readFileSync(filePath, 'utf8')
+        const match = content.match(/importScripts\([^)]+\)/)
+        if (match?.length > 1) throw new Error('Multiple importScripts found in ' + filePath)
+        const newContent = content.replace(/importScripts\(\w+\.\w+/, "'/'+location.pathname.split('/').slice(0, -4).join('/')")
+        fs.writeFileSync(filePath, newContent, 'utf8')
+        patched = true
+    }
+    if (!patched) throw new Error('No importScripts found in any worker files')
+}

src/index.ts

@@ -17,8 +17,6 @@
 import { getServerInfo } from './mineflayer/mc-protocol'
 import { onGameLoad } from './inventoryWindows'
 import initCollisionShapes from './getCollisionInteractionShapes'
-import protocolMicrosoftAuth from 'minecraft-protocol/src/client/microsoftAuth'
-import microsoftAuthflow from './microsoftAuthflow'
 import { Duplex } from 'stream'
 
 import './scaleInterface'
@@ -75,7 +73,7 @@
 import './devReload'
 import './water'
 import { ConnectOptions, loadMinecraftData, getVersionAutoSelect, downloadOtherGameData, downloadAllMinecraftData } from './connect'
-import { ref, subscribe } from 'valtio'
+import { subscribe } from 'valtio'
 import { signInMessageState } from './react/SignInMessageProvider'
 import { updateAuthenticatedAccountData, updateLoadedServerData, updateServerConnectionHistory } from './react/serversStorage'
 import packetsPatcher from './mineflayer/plugins/packetsPatcher'
@@ -97,6 +95,7 @@
 import { appViewer } from './appViewer'
 import './appViewerLoad'
 import { registerOpenBenchmarkListener } from './benchmark'
+import { getProtocolClientGetter } from './protocolWorker/protocolMain'
 
 window.debug = debug
 window.beforeRenderFrame = []
@@ -161,11 +160,6 @@
       }
     })
   }
-  if (sessionStorage.delayLoadUntilClick) {
-    await new Promise(resolve => {
-      window.addEventListener('click', resolve)
-    })
-  }
 
   miscUiState.hasErrors = false
   lastConnectOptions.value = connectOptions
@@ -183,21 +177,21 @@
 
   const { renderDistance: renderDistanceSingleplayer, multiplayerRenderDistance } = options
 
-  const parsedServer = parseServerAddress(connectOptions.server)
-  const server = { host: parsedServer.host, port: parsedServer.port }
+  const serverParsed = parseServerAddress(connectOptions.server)
+  const server = { host: serverParsed.host, port: serverParsed.port }
   if (connectOptions.proxy?.startsWith(':')) {
     connectOptions.proxy = `${location.protocol}//${location.hostname}${connectOptions.proxy}`
   }
   if (connectOptions.proxy && location.port !== '80' && location.port !== '443' && !/:\d+$/.test(connectOptions.proxy)) {
     const https = connectOptions.proxy.startsWith('https://') || location.protocol === 'https:'
     connectOptions.proxy = `${connectOptions.proxy}:${https ? 443 : 80}`
   }
-  const parsedProxy = parseServerAddress(connectOptions.proxy, false)
-  const proxy = { host: parsedProxy.host, port: parsedProxy.port }
+  const proxyParsed = parseServerAddress(connectOptions.proxy, false)
+  const proxy = { host: proxyParsed.host, port: proxyParsed.port }
   let { username } = connectOptions
 
   if (connectOptions.server) {
-    console.log(`connecting to ${server.host}:${server.port ?? 25_565}`)
+    console.log(`connecting to ${serverParsed.serverIpFull}`)
   }
   console.log('using player username', username)
 
@@ -237,14 +231,13 @@
       })
     }
   }
-  let lastPacket = undefined as string | undefined
+  const lastPacket = undefined as string | undefined
   const onPossibleErrorDisconnect = () => {
     if (lastPacket && bot?._client && bot._client.state !== states.PLAY) {
       appStatusState.descriptionHint = `Last Server Packet: ${lastPacket}`
     }
   }
   const handleError = (err) => {
-    console.error(err)
     if (err === 'ResizeObserver loop completed with undelivered notifications.') {
       return
     }
@@ -278,16 +271,14 @@
 
   let clientDataStream: Duplex | undefined
 
-  if (connectOptions.server && !connectOptions.viewerWsConnect && !parsedServer.isWebSocket) {
+  if (connectOptions.server && !connectOptions.viewerWsConnect && !serverParsed.isWebSocket) {
     console.log(`using proxy ${proxy.host}:${proxy.port || location.port}`)
     net['setProxy']({ hostname: proxy.host, port: proxy.port })
   }
 
   const renderDistance = singleplayer ? renderDistanceSingleplayer : multiplayerRenderDistance
-  let updateDataAfterJoin = () => { }
   let localServer
   let localReplaySession: ReturnType<typeof startLocalReplayServer> | undefined
-  let lastKnownKickReason = undefined as string | undefined
   try {
     const serverOptions = defaultsDeep({}, connectOptions.serverOverrides ?? {}, options.localServerOptions, defaultServerOptions)
     Object.assign(serverOptions, connectOptions.serverOverridesFlat ?? {})
@@ -406,30 +397,12 @@
     }
     setLoadingScreenStatus(initialLoadingText)
 
-    if (parsedServer.isWebSocket) {
-      clientDataStream = (await getWebsocketStream(server.host)).mineflayerStream
-    }
-
-    let newTokensCacheResult = null as any
-    const cachedTokens = typeof connectOptions.authenticatedAccount === 'object' ? connectOptions.authenticatedAccount.cachedTokens : {}
-    const authData = connectOptions.authenticatedAccount ? await microsoftAuthflow({
-      tokenCaches: cachedTokens,
-      proxyBaseUrl: connectOptions.proxy,
-      setProgressText (text) {
-        setLoadingScreenStatus(text)
-      },
-      setCacheResult (result) {
-        newTokensCacheResult = result
-      },
-      connectingServer: server.host
-    }) : undefined
-
     if (p2pMultiplayer) {
       clientDataStream = await connectToPeer(connectOptions.peerId!, connectOptions.peerOptions)
     }
     if (connectOptions.viewerWsConnect) {
       const { version, time, requiresPass } = await getViewerVersionData(connectOptions.viewerWsConnect)
-      let password
+      let password: string | null = null
       if (requiresPass) {
         password = prompt('Enter password')
         if (!password) {
@@ -454,6 +427,8 @@
     }
 
     const brand = clientDataStream ? 'minecraft-web-client' : undefined
+    const createClient = await getProtocolClientGetter(proxy, connectOptions, serverParsed)
+
     bot = mineflayer.createBot({
       host: server.host,
       port: server.port ? +server.port : undefined,
@@ -474,53 +449,13 @@
         connect () { },
         Client: CustomChannelClient as any,
       } : {},
-      onMsaCode (data) {
-        signInMessageState.code = data.user_code
-        signInMessageState.link = data.verification_uri
-        signInMessageState.expiresOn = Date.now() + data.expires_in * 1000
-      },
-      sessionServer: authData?.sessionEndpoint?.toString(),
-      auth: connectOptions.authenticatedAccount ? async (client, options) => {
-        authData!.setOnMsaCodeCallback(options.onMsaCode)
-        authData?.setConnectingVersion(client.version)
-        //@ts-expect-error
-        client.authflow = authData!.authFlow
-        try {
-          signInMessageState.abortController = ref(new AbortController())
-          await Promise.race([
-            protocolMicrosoftAuth.authenticate(client, options),
-            new Promise((_r, reject) => {
-              signInMessageState.abortController.signal.addEventListener('abort', () => {
-                reject(new UserError('Aborted by user'))
-              })
-            })
-          ])
-          if (signInMessageState.shouldSaveToken) {
-            updateAuthenticatedAccountData(accounts => {
-              const existingAccount = accounts.find(a => a.username === client.username)
-              if (existingAccount) {
-                existingAccount.cachedTokens = { ...existingAccount.cachedTokens, ...newTokensCacheResult }
-              } else {
-                accounts.push({
-                  username: client.username,
-                  cachedTokens: { ...cachedTokens, ...newTokensCacheResult }
-                })
-              }
-              return accounts
-            })
-            updateDataAfterJoin = () => {
-              updateLoadedServerData(s => ({ ...s, authenticatedAccountOverride: client.username }), connectOptions.serverIndex)
-            }
-          } else {
-            updateDataAfterJoin = () => {
-              updateLoadedServerData(s => ({ ...s, authenticatedAccountOverride: undefined }), connectOptions.serverIndex)
-            }
-          }
-          setLoadingScreenStatus('Authentication successful. Logging in to server')
-        } finally {
-          signInMessageState.code = ''
+      get client () {
+        if (clientDataStream || singleplayer || p2pMultiplayer || localReplaySession || connectOptions.viewerWsConnect || (!options.protocolWorkerOptimisation && !serverParsed.isWebSocket)) {
+          return undefined
         }
-      } : undefined,
+        return createClient.call(this)
+      },
+      // auth: connectOptions.authenticatedAccount ?  : undefined,
       username,
       viewDistance: renderDistance,
       checkTimeoutInterval: 240 * 1000,
@@ -553,49 +488,7 @@
     } else if (clientDataStream) {
       // bot.emit('inject_allowed')
       bot._client.emit('connect')
     } else {
-      const setupConnectHandlers = () => {
-        Socket.prototype['handleStringMessage'] = function (message: string) {
-          if (message.startsWith('proxy-message') || message.startsWith('proxy-command:')) { // for future
-            return false
-          }
-          if (message.startsWith('proxy-shutdown:')) {
-            lastKnownKickReason = message.slice('proxy-shutdown:'.length)
-            return false
-          }
-          return true
-        }
-        bot._client.socket.on('connect', () => {
-          console.log('Proxy WebSocket connection established')
-          //@ts-expect-error
-          bot._client.socket._ws.addEventListener('close', () => {
-            console.log('WebSocket connection closed')
-            setTimeout(() => {
-              if (bot) {
-                bot.emit('end', 'WebSocket connection closed with unknown reason')
-              }
-            }, 1000)
-          })
-          bot._client.socket.on('close', () => {
-            setTimeout(() => {
-              if (bot) {
-                bot.emit('end', 'WebSocket connection closed with unknown reason')
-              }
-            })
-          })
-        })
-      }
-      // socket setup actually can be delayed because of dns lookup
-      if (bot._client.socket) {
-        setupConnectHandlers()
-      } else {
-        const originalSetSocket = bot._client.setSocket.bind(bot._client)
-        bot._client.setSocket = (socket) => {
-          if (!bot) return
-          originalSetSocket(socket)
-          setupConnectHandlers()
-        }
-      }
 
     }
   } catch (err) {
@@ -628,7 +521,7 @@
   })
 
   const packetBeforePlay = (_, __, ___, fullBuffer) => {
-    lastPacket = fullBuffer.toString()
+    // lastPacket = fullBuffer.toString()
   }
   bot._client.on('packet', packetBeforePlay as any)
   const playStateSwitch = (newState) => {
@@ -641,9 +534,6 @@
   bot.on('end', (endReason) => {
     if (ended) return
     console.log('disconnected for', endReason)
-    if (endReason === 'socketClosed') {
-      endReason = lastKnownKickReason ?? 'Connection with proxy server lost'
-    }
     setLoadingScreenStatus(`You have been disconnected from the server. End reason:\n${endReason}`, true)
     appStatusState.showReconnect = true
     onPossibleErrorDisconnect()
@@ -715,7 +605,6 @@
         localStorage.removeItem('lastConnectOptions')
       }
       connectOptions.onSuccessfulPlay?.()
-      updateDataAfterJoin()
       if (connectOptions.autoLoginPassword) {
         setTimeout(() => {
           bot.chat(`/login ${connectOptions.autoLoginPassword}`)