CI/CD Linting + Smoke

.github/workflows/ci.yml

@@ -0,0 +1,90 @@
+name: CI
+
+on:
+  push:
+    branches: ['**']
+  pull_request:
+    branches: ['**']
+
+jobs:
+  lint-typecheck:
+    name: Lint & Type-check (backend)
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: latest
+
+      - name: Setup Node 24
+        uses: actions/setup-node@v4
+        with:
+          node-version: '24'
+          cache: 'pnpm'
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Build shared
+        run: pnpm run build:shared
+
+      - name: Lint backend
+        run: pnpm --filter @notblox/back run lint
+
+      - name: Type-check backend
+        run: pnpm --filter @notblox/back run build
+
+  docker-smoke:
+    name: Docker build & smoke test
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Build image
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          load: true
+          tags: notblox-game-server:ci
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+
+      - name: Start container
+        run: docker run -d --name smoke notblox-game-server:ci
+
+      - name: Wait for healthy
+        run: |
+          for i in $(seq 1 12); do
+            STATUS=$(docker inspect --format='{{.State.Health.Status}}' smoke 2>/dev/null || echo 'missing')
+            echo "Attempt $i: $STATUS"
+            if [ "$STATUS" = "healthy" ]; then
+              echo "Container is healthy"
+              exit 0
+            fi
+            if [ "$STATUS" = "unhealthy" ]; then
+              echo "Container became unhealthy"
+              docker logs smoke
+              exit 1
+            fi
+            sleep 5
+          done
+          echo "Timed out waiting for container to become healthy"
+          docker logs smoke
+          exit 1
+
+      - name: Print logs
+        if: always()
+        run: docker logs smoke
+
+      - name: Stop container
+        if: always()
+        run: docker rm -f smoke

Dockerfile

@@ -42,4 +42,9 @@ COPY back/src ./back/src
 
 # Run from back/ so Node resolves tsx from back/node_modules
 WORKDIR /app/back
+
+# Probe TCP port 8001 – container is healthy once the WS server is accepting connections
+HEALTHCHECK --interval=5s --timeout=3s --start-period=15s --retries=3 \
+  CMD node -e "const n=require('net').createConnection(8001,'localhost'); n.on('connect',()=>{n.destroy();process.exit(0);}); n.on('error',()=>process.exit(1));"
+
 CMD ["node", "--import", "tsx/esm", "src/sandbox.ts"]

back/eslint.config.ts

@@ -0,0 +1,9 @@
+import js from "@eslint/js";
+import globals from "globals";
+import tseslint from "typescript-eslint";
+import { defineConfig } from "eslint/config";
+
+export default defineConfig([
+  { files: ["**/*.{js,mjs,cjs,ts,mts,cts}"], plugins: { js }, extends: ["js/recommended"], languageOptions: { globals: globals.browser } },
+  tseslint.configs.recommended,
+]);

back/package.json

@@ -10,30 +10,32 @@
     "dev": "tsx watch src/sandbox.ts",
     "build": "tsc --noEmit",
     "start": "node --import tsx/esm src/sandbox.ts",
-    "lint": "eslint src/**/*.ts",
-    "format": "eslint src/**/*.ts --fix"
+    "lint": "eslint src/",
+    "format": "eslint src/ --fix"
   },
   "author": "iercann",
   "license": "MIT",
   "engines": {
     "node": ">=24"
   },
   "overrides": {
-    "minimatch": "^10.2.1"
+    "minimatch": "^10.2.1",
+    "jiti": "latest"
   },
   "dependencies": {
-    "@notblox/shared": "workspace:*",
-    "tsx": "^4.0.0",
     "@dimforge/rapier3d-compat": "^0.14.0",
+    "@notblox/shared": "workspace:*",
     "dotenv": "^16.3.1",
     "msgpackr": "^1.9.9",
     "node-three-gltf": "^1.8.3",
     "pako": "^2.1.0",
     "rate-limiter-flexible": "^5.0.3",
     "three": "^0.183.0",
+    "tsx": "^4.0.0",
     "uWebSockets.js": "github:uNetworking/uWebSockets.js#v20.57.0"
   },
   "devDependencies": {
+    "@eslint/js": "^10.0.1",
     "@types/node": "^24.0.0",
     "@types/pako": "^2.0.3",
     "@types/three": "^0.183.0",
@@ -42,6 +44,7 @@
     "@typescript-eslint/parser": "latest",
     "eslint": "latest",
     "globals": "latest",
+    "jiti": "^2.6.1",
     "typescript": "^5.7.3",
     "typescript-eslint": "latest"
   }

back/src/ecs/component/WebsocketComponent.ts

@@ -1,4 +1,5 @@
 import { Component } from '@shared/component/Component.js'
+import type { WebSocket } from 'uWebSockets.js'
 
 export class WebSocketComponent extends Component {
   /**
@@ -10,7 +11,7 @@ export class WebSocketComponent extends Component {
    */
   constructor(
     entityId: number,
-    public ws: any,
+    public ws: WebSocket<unknown>,
     public isFirstSnapshotSent = false
   ) {
     super(entityId)

back/src/ecs/entity/Player.ts

@@ -17,11 +17,12 @@ import { ColorComponent } from '@shared/component/ColorComponent.js'
 import { ServerMeshComponent } from '@shared/component/ServerMeshComponent.js'
 import { TextComponent } from '@shared/component/TextComponent.js'
 import { PhysicsPropertiesComponent } from '../component/physics/PhysicsPropertiesComponent.js'
+import type { WebSocket } from 'uWebSockets.js'
 
 export class Player {
   entity: Entity
 
-  constructor(ws: WebSocket, initialX: number, initialY: number, initialZ: number) {
+  constructor(ws: WebSocket<unknown>, initialX: number, initialY: number, initialZ: number) {
     this.entity = EntityManager.createEntity(SerializedEntityType.PLAYER)
     // Tag
     const playerComponent = new PlayerComponent(this.entity.id)

back/src/ecs/system/network/NetworkSystem.ts

@@ -77,7 +77,7 @@ export class NetworkSystem {
   }
 
   // Broadcasts a message to all connected clients.
-  private broadcast(entities: Entity[], message: any): void {
+  private broadcast(entities: Entity[], message: Uint8Array): void {
     for (const entity of entities) {
       const websocketComponent = entity.getComponent(WebSocketComponent)
       if (websocketComponent) {

back/src/ecs/system/network/WebsocketSystem.ts

@@ -4,6 +4,7 @@ import {
   HttpRequest,
   HttpResponse,
   SSLApp,
+  WebSocket,
   us_listen_socket,
   us_socket_context_t,
 } from 'uWebSockets.js'
@@ -38,7 +39,9 @@ import { EntityManager } from '@shared/system/EntityManager.js'
 import { MessageListComponent } from '@shared/component/MessageComponent.js'
 import { ChatComponent } from '../../component/tag/TagChatComponent.js'
 import { WebSocketComponent } from '../../component/WebsocketComponent.js'
-type MessageHandler = (ws: any, message: any) => void
+
+type PlayerData = { player?: Player }
+type MessageHandler = (ws: WebSocket<PlayerData>, message: ClientMessage) => void
 
 export class WebsocketSystem {
   private port: number = 8001
@@ -132,7 +135,7 @@ export class WebsocketSystem {
       res.end(JSON.stringify(healthData))
     })
 
-    app.ws('/*', {
+    app.ws<PlayerData>('/*', {
       idleTimeout: 32,
       maxBackpressure: 1024,
       maxPayloadLength: 512,
@@ -160,8 +163,8 @@ export class WebsocketSystem {
       return
     }
 
-    res.upgrade(
-      {}, // WebSocket handler will go here
+    res.upgrade<PlayerData>(
+      {},
       req.getHeader('sec-websocket-key'),
       req.getHeader('sec-websocket-protocol'),
       req.getHeader('sec-websocket-extensions'),
@@ -178,15 +181,21 @@ export class WebsocketSystem {
   }
 
   private initializeMessageHandlers() {
-    this.addMessageHandler(ClientMessageType.INPUT, this.handleInputMessage.bind(this))
-    this.addMessageHandler(ClientMessageType.CHAT_MESSAGE, this.handleChatMessage.bind(this))
+    this.addMessageHandler(
+      ClientMessageType.INPUT,
+      this.handleInputMessage.bind(this) as MessageHandler
+    )
+    this.addMessageHandler(
+      ClientMessageType.CHAT_MESSAGE,
+      this.handleChatMessage.bind(this) as MessageHandler
+    )
     this.addMessageHandler(
       ClientMessageType.PROXIMITY_PROMPT_INTERACT,
-      this.handleProximityPromptInteractMessage.bind(this)
+      this.handleProximityPromptInteractMessage.bind(this) as MessageHandler
     )
     this.addMessageHandler(
       ClientMessageType.SET_PLAYER_NAME,
-      this.handleSetPlayerNameMessage.bind(this)
+      this.handleSetPlayerNameMessage.bind(this) as MessageHandler
     )
   }
 
@@ -198,8 +207,8 @@ export class WebsocketSystem {
     this.messageHandlers.delete(type)
   }
 
-  private onMessage(ws: any, message: any) {
-    const clientMessage: ClientMessage = unpack(message)
+  private onMessage(ws: WebSocket<PlayerData>, message: ArrayBuffer) {
+    const clientMessage: ClientMessage = unpack(Buffer.from(message))
     const handler = this.messageHandlers.get(clientMessage.t)
     if (handler) {
       handler(ws, clientMessage)
@@ -209,12 +218,12 @@ export class WebsocketSystem {
   // TODO: Create EventOnPlayerConnect and EventOnPlayerDisconnect to respects ECS
   // Might be useful to query the chat and send a message to all players when a player connects or disconnects
   // Also could append scriptable events to be triggered on connect/disconnect depending on the game
-  private async onConnect(ws: any) {
+  private async onConnect(ws: WebSocket<PlayerData>) {
     const ipBuffer = ws.getRemoteAddressAsText() as ArrayBuffer
     const ip = Buffer.from(ipBuffer).toString()
     if (await this.isRateLimited(ip)) {
       // Respond to the client indicating that the connection is rate limited
-      return ws.close(429, 'Rate limit exceeded')
+      return ws.close()
     }
     const player = new Player(ws, Math.random() * 5, 5, Math.random() * 5)
     const connectionMessage: ConnectionMessage = {
@@ -223,7 +232,7 @@ export class WebsocketSystem {
       tickRate: config.SERVER_TICKRATE,
     }
     // player.entity.addComponent(new RandomizeComponent(player.entity.id))
-    ws.player = player
+    ws.getUserData().player = player
     ws.send(NetworkSystem.compress(connectionMessage), true)
 
     EventSystem.addEvent(
@@ -236,12 +245,12 @@ export class WebsocketSystem {
     this.players.push(player)
   }
 
-  private onDrain(ws: any) {
+  private onDrain(ws: WebSocket<PlayerData>) {
     console.log('WebSocket backpressure: ' + ws.getBufferedAmount())
   }
 
-  private onClose(ws: any) {
-    const disconnectedPlayer: Player = ws.player
+  private onClose(ws: WebSocket<PlayerData>) {
+    const disconnectedPlayer = ws.getUserData().player
     if (!disconnectedPlayer) {
       console.error('Disconnect: Player not found?', ws)
       return
@@ -260,8 +269,8 @@ export class WebsocketSystem {
     entity.removeComponent(WebSocketComponent)
   }
 
-  private async handleInputMessage(ws: any, message: InputMessage) {
-    const player: Player = ws.player
+  private handleInputMessage(ws: WebSocket<PlayerData>, message: InputMessage) {
+    const player = ws.getUserData().player
     if (!player) {
       console.error(`Player with WS ${ws} not found.`)
       return
@@ -283,9 +292,13 @@ export class WebsocketSystem {
     this.inputProcessingSystem.receiveInputPacket(player.entity, message)
   }
 
-  private handleChatMessage(ws: any, message: ChatMessage) {
+  private handleChatMessage(ws: WebSocket<PlayerData>, message: ChatMessage) {
     console.log('Chat message received', message)
-    const player: Player = ws.player
+    const player = ws.getUserData().player
+    if (!player) {
+      console.error(`Player with WS ${ws} not found.`)
+      return
+    }
 
     const { content } = message
     if (!content || typeof content !== 'string' || content.length === 0) {
@@ -301,8 +314,11 @@ export class WebsocketSystem {
 
     EventSystem.addEvent(new MessageEvent(player.entity.id, playerName, content))
   }
-  private handleProximityPromptInteractMessage(ws: any, message: ProximityPromptInteractMessage) {
-    const player: Player = ws.player
+  private handleProximityPromptInteractMessage(
+    ws: WebSocket<PlayerData>,
+    message: ProximityPromptInteractMessage
+  ) {
+    const player = ws.getUserData().player
     if (!player) {
       console.error(`Player with WS ${ws} not found.`)
       return
@@ -311,8 +327,8 @@ export class WebsocketSystem {
     EventSystem.addEvent(new ProximityPromptInteractEvent(player.entity.id, eId))
   }
 
-  private handleSetPlayerNameMessage(ws: any, message: SetPlayerNameMessage) {
-    const player: Player = ws.player
+  private handleSetPlayerNameMessage(ws: WebSocket<PlayerData>, message: SetPlayerNameMessage) {
+    const player = ws.getUserData().player
     if (!player) {
       console.error(`Player with WS ${ws} not found.`)
       return

back/src/scripts/defaultScript.ts

@@ -137,7 +137,7 @@ const cube = new Cube({
 })
 const proximityPromptComponent = new ProximityPromptComponent(cube.entity.id, {
   text: 'Press E to change color',
-  onInteract: (interactingEntity) => {
+  onInteract: () => {
     cube.entity
       .getComponent(DynamicRigidBodyComponent)!
       .body!.applyImpulse(new Rapier.Vector3(0, 5, 0), true)
@@ -171,7 +171,7 @@ for (let i = 1; i < 10; i++) {
   const y = 5
   const z = 20 * i
 
-  let wheelConfig: Record<string, number> = {}
+  let wheelConfig: Record<string, number>
   if (i < 5) {
     wheelConfig = {
       frontLeft: Math.max(1, i / 2.5),