@air-jam/server 0.1.0

package/dist/chunk-NWAVO5AJ.js

@@ -0,0 +1,749 @@
+// src/index.ts
+import {
+  controllerInputSchema,
+  controllerJoinSchema,
+  controllerLeaveSchema,
+  controllerStateSchema,
+  controllerSystemSchema,
+  ErrorCode,
+  hostJoinAsChildSchema,
+  hostRegisterSystemSchema,
+  hostRegistrationSchema,
+  systemLaunchGameSchema
+} from "@air-jam/sdk/protocol";
+import Color from "color";
+import cors from "cors";
+import express from "express";
+import { createServer } from "http";
+import { Server } from "socket.io";
+import { v4 as uuidv4 } from "uuid";
+
+// src/services/auth-service.ts
+import { and, eq } from "drizzle-orm";
+
+// src/db.ts
+import * as dotenv from "dotenv";
+import { boolean, pgTable, text, timestamp } from "drizzle-orm/pg-core";
+import { drizzle } from "drizzle-orm/postgres-js";
+import postgres from "postgres";
+dotenv.config();
+var apiKeys = pgTable("api_keys", {
+  id: text("id").primaryKey(),
+  gameId: text("game_id").notNull().unique(),
+  // One API key per game
+  key: text("key").notNull().unique(),
+  isActive: boolean("is_active").default(true).notNull(),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  lastUsedAt: timestamp("last_used_at")
+});
+var connectionString = process.env.DATABASE_URL;
+var client = connectionString ? postgres(connectionString) : null;
+var db = client ? drizzle(client) : null;
+
+// src/services/auth-service.ts
+var AuthService = class {
+  masterKey;
+  databaseUrl;
+  isDevMode;
+  constructor() {
+    this.masterKey = process.env.AIR_JAM_MASTER_KEY;
+    this.databaseUrl = process.env.DATABASE_URL;
+    this.isDevMode = !this.masterKey && !this.databaseUrl;
+    if (this.isDevMode) {
+      console.log(
+        "[server] Running in development mode - authentication disabled"
+      );
+    } else if (this.masterKey && !this.databaseUrl) {
+      console.log(
+        "[server] Running with master key authentication (no database required)"
+      );
+    } else if (this.databaseUrl) {
+      console.log("[server] Running with database authentication");
+    }
+  }
+  /**
+   * Verify an API key
+   * Returns verification result with optional error message
+   * In dev mode, always returns success
+   */
+  async verifyApiKey(apiKey) {
+    if (this.isDevMode) {
+      return { isVerified: true };
+    }
+    if (!apiKey) {
+      return {
+        isVerified: false,
+        error: "Unauthorized: Invalid or Missing API Key"
+      };
+    }
+    if (this.masterKey && apiKey === this.masterKey) {
+      return { isVerified: true };
+    }
+    if (!this.databaseUrl || !db) {
+      return {
+        isVerified: false,
+        error: "Unauthorized: Invalid or Missing API Key"
+      };
+    }
+    try {
+      const [keyRecord] = await db.select().from(apiKeys).where(and(eq(apiKeys.key, apiKey), eq(apiKeys.isActive, true))).limit(1);
+      if (keyRecord) {
+        db.update(apiKeys).set({ lastUsedAt: /* @__PURE__ */ new Date() }).where(eq(apiKeys.id, keyRecord.id)).catch(
+          (err) => console.error("[server] Failed to update lastUsedAt", err)
+        );
+        return { isVerified: true };
+      }
+      return {
+        isVerified: false,
+        error: "Unauthorized: Invalid or Missing API Key"
+      };
+    } catch (error) {
+      console.error("[server] Database error during key verification", error);
+      return {
+        isVerified: false,
+        error: "Internal Server Error"
+      };
+    }
+  }
+};
+var authService = new AuthService();
+
+// src/services/room-manager.ts
+var RoomManager = class {
+  rooms = /* @__PURE__ */ new Map();
+  hostIndex = /* @__PURE__ */ new Map();
+  controllerIndex = /* @__PURE__ */ new Map();
+  /**
+   * Get a room by ID
+   */
+  getRoom(roomId) {
+    return this.rooms.get(roomId);
+  }
+  /**
+   * Create or update a room
+   */
+  setRoom(roomId, session) {
+    this.rooms.set(roomId, session);
+  }
+  /**
+   * Delete a room
+   */
+  deleteRoom(roomId) {
+    this.rooms.delete(roomId);
+  }
+  /**
+   * Get room ID by host socket ID
+   */
+  getRoomByHostId(socketId) {
+    return this.hostIndex.get(socketId);
+  }
+  /**
+   * Associate a host socket with a room
+   */
+  setHostRoom(socketId, roomId) {
+    this.hostIndex.set(socketId, roomId);
+  }
+  /**
+   * Remove host association
+   */
+  deleteHost(socketId) {
+    this.hostIndex.delete(socketId);
+  }
+  /**
+   * Get controller info by socket ID
+   */
+  getControllerInfo(socketId) {
+    return this.controllerIndex.get(socketId);
+  }
+  /**
+   * Associate a controller socket with room and controller ID
+   */
+  setController(socketId, entry) {
+    this.controllerIndex.set(socketId, entry);
+  }
+  /**
+   * Remove controller association
+   */
+  deleteController(socketId) {
+    this.controllerIndex.delete(socketId);
+  }
+  /**
+   * Get the active host socket ID based on focus
+   */
+  getActiveHostId(session) {
+    return session.focus === "GAME" && session.childHostSocketId ? session.childHostSocketId : session.masterHostSocketId;
+  }
+  /**
+   * Remove a room and clean up all associations
+   */
+  removeRoom(roomId, io2, reason) {
+    const session = this.rooms.get(roomId);
+    if (!session) return;
+    io2.to(roomId).emit("server:hostLeft", { roomId, reason });
+    session.controllers.forEach((controller) => {
+      this.controllerIndex.delete(controller.socketId);
+    });
+    this.hostIndex.delete(session.masterHostSocketId);
+    if (session.childHostSocketId) {
+      this.hostIndex.delete(session.childHostSocketId);
+    }
+    this.rooms.delete(roomId);
+  }
+  /**
+   * Get all rooms (for debugging/monitoring)
+   */
+  getAllRooms() {
+    return this.rooms;
+  }
+};
+var roomManager = new RoomManager();
+
+// src/index.ts
+var PORT = Number(process.env.PORT ?? 4e3);
+var app = express();
+app.use(cors());
+app.use(express.json());
+app.get("/health", (_, res) => {
+  res.json({ ok: true });
+});
+var httpServer = createServer(app);
+var io = new Server(httpServer, {
+  cors: {
+    origin: "*"
+  },
+  pingInterval: 2e3,
+  pingTimeout: 5e3
+});
+var emitError = (socketId, payload) => {
+  io.to(socketId).emit("server:error", payload);
+};
+io.on(
+  "connection",
+  (socket) => {
+    socket.on(
+      "host:registerSystem",
+      async (payload, callback) => {
+        const parsed = hostRegisterSystemSchema.safeParse(payload);
+        if (!parsed.success) {
+          callback({
+            ok: false,
+            message: parsed.error.message,
+            code: ErrorCode.INVALID_PAYLOAD
+          });
+          return;
+        }
+        const { roomId, apiKey } = parsed.data;
+        const verification = await authService.verifyApiKey(apiKey);
+        if (!verification.isVerified) {
+          console.warn(
+            `[server] Unauthorized host registration attempt for room ${roomId}`
+          );
+          callback({
+            ok: false,
+            message: verification.error,
+            code: ErrorCode.INVALID_API_KEY
+          });
+          return;
+        }
+        let session = roomManager.getRoom(roomId);
+        if (session) {
+          session.masterHostSocketId = socket.id;
+          roomManager.setRoom(roomId, session);
+        } else {
+          console.log(`[server] Creating room ${roomId}`);
+          session = {
+            roomId,
+            masterHostSocketId: socket.id,
+            focus: "SYSTEM",
+            controllers: /* @__PURE__ */ new Map(),
+            maxPlayers: 32,
+            // Default increased to 32 to allow for observers/queue
+            gameState: "paused"
+          };
+          roomManager.setRoom(roomId, session);
+        }
+        roomManager.setHostRoom(socket.id, roomId);
+        socket.join(roomId);
+        callback({ ok: true, roomId });
+        io.to(roomId).emit("server:roomReady", { roomId });
+      }
+    );
+    socket.on(
+      "system:launchGame",
+      (payload, callback) => {
+        const parsed = systemLaunchGameSchema.safeParse(payload);
+        if (!parsed.success) {
+          callback({
+            ok: false,
+            message: parsed.error.message,
+            code: ErrorCode.INVALID_PAYLOAD
+          });
+          return;
+        }
+        const { roomId, gameUrl } = parsed.data;
+        const session = roomManager.getRoom(roomId);
+        if (!session) {
+          callback({
+            ok: false,
+            message: "Room not found",
+            code: ErrorCode.ROOM_NOT_FOUND
+          });
+          return;
+        }
+        if (session.masterHostSocketId !== socket.id) {
+          callback({
+            ok: false,
+            message: "Unauthorized: Not System Host",
+            code: ErrorCode.UNAUTHORIZED
+          });
+          return;
+        }
+        if (session.childHostSocketId) {
+          callback({
+            ok: false,
+            message: "Game already active",
+            code: ErrorCode.ALREADY_CONNECTED
+          });
+          return;
+        }
+        if (session.joinToken && !session.childHostSocketId) {
+          callback({ ok: true, joinToken: session.joinToken });
+          return;
+        }
+        const joinToken = uuidv4();
+        session.joinToken = joinToken;
+        session.activeControllerUrl = gameUrl;
+        console.log(`[server] Launching game in room ${roomId}`);
+        io.to(roomId).emit("client:loadUi", { url: gameUrl });
+        callback({ ok: true, joinToken });
+      }
+    );
+    socket.on(
+      "host:joinAsChild",
+      (payload, callback) => {
+        const parsed = hostJoinAsChildSchema.safeParse(payload);
+        if (!parsed.success) {
+          callback({
+            ok: false,
+            message: parsed.error.message,
+            code: ErrorCode.INVALID_PAYLOAD
+          });
+          return;
+        }
+        const { roomId, joinToken } = parsed.data;
+        const session = roomManager.getRoom(roomId);
+        if (!session) {
+          callback({
+            ok: false,
+            message: "Room not found",
+            code: ErrorCode.ROOM_NOT_FOUND
+          });
+          return;
+        }
+        if (session.joinToken !== joinToken) {
+          console.warn(
+            `[server] Invalid join token for room ${roomId}. Expected ${session.joinToken}, got ${joinToken}`
+          );
+          callback({
+            ok: false,
+            message: "Invalid Join Token",
+            code: ErrorCode.INVALID_TOKEN
+          });
+          return;
+        }
+        console.log(`[server] Game host joined room ${roomId}`);
+        session.childHostSocketId = socket.id;
+        session.focus = "GAME";
+        roomManager.setHostRoom(socket.id, roomId);
+        socket.join(roomId);
+        setTimeout(() => {
+          session.controllers.forEach((c) => {
+            const notice = {
+              controllerId: c.controllerId,
+              nickname: c.nickname,
+              player: c.playerProfile
+            };
+            socket.emit("server:controllerJoined", notice);
+          });
+          const statePayload = {
+            roomId,
+            state: {
+              gameState: session.gameState
+            }
+          };
+          socket.emit("server:state", statePayload);
+        }, 100);
+        callback({ ok: true, roomId });
+      }
+    );
+    socket.on("system:closeGame", (payload) => {
+      const { roomId } = payload;
+      const session = roomManager.getRoom(roomId);
+      if (!session) {
+        return;
+      }
+      if (session.masterHostSocketId !== socket.id) {
+        return;
+      }
+      console.log(`[server] Closing game in room ${roomId}`);
+      if (session.childHostSocketId) {
+        const childSocket = io.sockets.sockets.get(session.childHostSocketId);
+        if (childSocket) {
+          childSocket.disconnect(true);
+        }
+      }
+      session.focus = "SYSTEM";
+      session.childHostSocketId = void 0;
+      session.joinToken = void 0;
+      session.activeControllerUrl = void 0;
+      io.to(roomId).emit("client:unloadUi");
+    });
+    socket.on(
+      "host:register",
+      async (payload, callback) => {
+        const parsed = hostRegistrationSchema.safeParse(payload);
+        if (!parsed.success) {
+          callback({
+            ok: false,
+            message: parsed.error.message,
+            code: ErrorCode.INVALID_PAYLOAD
+          });
+          return;
+        }
+        const { roomId, maxPlayers } = parsed.data;
+        let session = roomManager.getRoom(roomId);
+        if (session) {
+          session.masterHostSocketId = socket.id;
+          session.focus = "SYSTEM";
+        } else {
+          console.log(`[server] Creating standalone room ${roomId}`);
+          session = {
+            roomId,
+            masterHostSocketId: socket.id,
+            focus: "SYSTEM",
+            controllers: /* @__PURE__ */ new Map(),
+            maxPlayers,
+            gameState: "paused"
+          };
+          roomManager.setRoom(roomId, session);
+        }
+        roomManager.setHostRoom(socket.id, roomId);
+        socket.join(roomId);
+        callback({ ok: true, roomId });
+        io.to(roomId).emit("server:roomReady", { roomId });
+      }
+    );
+    socket.on("controller:join", (payload, callback) => {
+      const parsed = controllerJoinSchema.safeParse(payload);
+      if (!parsed.success) {
+        callback({
+          ok: false,
+          message: parsed.error.message,
+          code: ErrorCode.INVALID_PAYLOAD
+        });
+        return;
+      }
+      const { roomId, controllerId, nickname } = parsed.data;
+      const session = roomManager.getRoom(roomId);
+      if (!session) {
+        callback({
+          ok: false,
+          message: "Room not found",
+          code: ErrorCode.ROOM_NOT_FOUND
+        });
+        emitError(socket.id, {
+          code: ErrorCode.ROOM_NOT_FOUND,
+          message: "Room not found"
+        });
+        return;
+      }
+      if (session.controllers.size >= session.maxPlayers) {
+        callback({
+          ok: false,
+          message: "Room full",
+          code: ErrorCode.ROOM_FULL
+        });
+        emitError(socket.id, {
+          code: ErrorCode.ROOM_FULL,
+          message: "Room is full"
+        });
+        return;
+      }
+      const existing = session.controllers.get(controllerId);
+      if (existing) {
+        roomManager.deleteController(existing.socketId);
+      }
+      const PLAYER_COLORS = [
+        "#38bdf8",
+        "#a78bfa",
+        "#f472b6",
+        "#34d399",
+        "#fbbf24",
+        "#60a5fa",
+        "#c084fc",
+        "#fb7185",
+        "#4ade80",
+        "#f87171",
+        "#22d3ee",
+        "#a855f7",
+        "#ec4899",
+        "#10b981",
+        "#f59e0b",
+        "#3b82f6",
+        "#8b5cf6",
+        "#ef4444",
+        "#14b8a6",
+        "#f97316"
+      ];
+      const colorHex = PLAYER_COLORS[session.controllers.size % PLAYER_COLORS.length];
+      let color;
+      try {
+        color = Color(colorHex).hex();
+      } catch {
+        color = Color("#38bdf8").hex();
+      }
+      const playerProfile = {
+        id: controllerId,
+        label: nickname ?? `Player ${session.controllers.size}`,
+        color
+      };
+      const controllerSession = {
+        controllerId,
+        nickname,
+        socketId: socket.id,
+        playerProfile
+      };
+      session.controllers.set(controllerId, controllerSession);
+      roomManager.setController(socket.id, { roomId, controllerId });
+      socket.join(roomId);
+      const notice = {
+        controllerId,
+        nickname,
+        player: playerProfile
+      };
+      io.to(roomManager.getActiveHostId(session)).emit(
+        "server:controllerJoined",
+        notice
+      );
+      callback({ ok: true, controllerId, roomId });
+      const welcomePayload = {
+        controllerId,
+        roomId,
+        player: playerProfile
+      };
+      socket.emit("server:welcome", welcomePayload);
+      const statePayload = {
+        roomId,
+        state: {
+          gameState: session.gameState
+        }
+      };
+      socket.emit("server:state", statePayload);
+      if (session.activeControllerUrl) {
+        socket.emit("client:loadUi", { url: session.activeControllerUrl });
+      }
+      console.log(
+        `[server] Controller joined room ${roomId} (${session.controllers.size}/${session.maxPlayers} players)`
+      );
+    });
+    socket.on("controller:leave", (payload) => {
+      const parsed = controllerLeaveSchema.safeParse(payload);
+      if (!parsed.success) {
+        return;
+      }
+      const { roomId, controllerId } = parsed.data;
+      const session = roomManager.getRoom(roomId);
+      if (!session) {
+        return;
+      }
+      session.controllers.delete(controllerId);
+      roomManager.deleteController(socket.id);
+      const notice = { controllerId };
+      io.to(roomManager.getActiveHostId(session)).emit(
+        "server:controllerLeft",
+        notice
+      );
+      socket.leave(roomId);
+    });
+    socket.on("controller:input", (payload) => {
+      const result = controllerInputSchema.safeParse(payload);
+      if (!result.success) {
+        return;
+      }
+      const { roomId } = result.data;
+      const session = roomManager.getRoom(roomId);
+      if (!session) {
+        return;
+      }
+      const targetHostId = roomManager.getActiveHostId(session);
+      if (targetHostId) {
+        io.to(targetHostId).emit("server:input", result.data);
+      }
+    });
+    socket.on("controller:system", (payload) => {
+      const parsed = controllerSystemSchema.safeParse(payload);
+      if (!parsed.success) {
+        return;
+      }
+      const { roomId, command } = parsed.data;
+      const session = roomManager.getRoom(roomId);
+      if (!session) {
+        return;
+      }
+      if (command === "exit") {
+        console.log(`[server] Controller exit request in room ${roomId}`);
+        if (session.childHostSocketId) {
+          const childSocket = io.sockets.sockets.get(session.childHostSocketId);
+          if (childSocket) {
+            childSocket.disconnect(true);
+          }
+        }
+        session.focus = "SYSTEM";
+        session.childHostSocketId = void 0;
+        session.joinToken = void 0;
+        session.activeControllerUrl = void 0;
+        session.gameState = "paused";
+        io.to(roomId).emit("client:unloadUi");
+        if (session.masterHostSocketId) {
+          io.to(session.masterHostSocketId).emit("server:closeChild");
+        }
+      } else if (command === "toggle_pause") {
+        session.gameState = session.gameState === "playing" ? "paused" : "playing";
+        const statePayload = {
+          roomId,
+          state: {
+            gameState: session.gameState
+          }
+        };
+        io.to(roomId).emit("server:state", statePayload);
+      }
+    });
+    socket.on("host:system", (payload) => {
+      const parsed = controllerSystemSchema.safeParse(payload);
+      if (!parsed.success) {
+        return;
+      }
+      const { roomId, command } = parsed.data;
+      const session = roomManager.getRoom(roomId);
+      if (!session) {
+        return;
+      }
+      if (command === "toggle_pause") {
+        session.gameState = session.gameState === "playing" ? "paused" : "playing";
+        const statePayload = {
+          roomId,
+          state: {
+            gameState: session.gameState
+          }
+        };
+        io.to(roomId).emit("server:state", statePayload);
+      }
+    });
+    socket.on("host:state", (payload) => {
+      const result = controllerStateSchema.safeParse(payload);
+      if (!result.success) return;
+      const { roomId, state } = result.data;
+      const session = roomManager.getRoom(roomId);
+      if (session) {
+        if (state.gameState) {
+          session.gameState = state.gameState;
+        }
+        session.controllers.forEach((c) => {
+          io.to(c.socketId).emit("server:state", result.data);
+        });
+        if (session.masterHostSocketId) {
+          io.to(session.masterHostSocketId).emit("server:state", result.data);
+        }
+        if (session.childHostSocketId) {
+          io.to(session.childHostSocketId).emit("server:state", result.data);
+        }
+      }
+    });
+    socket.on("host:signal", (payload) => {
+      const roomId = roomManager.getRoomByHostId(socket.id);
+      if (!roomId) return;
+      const session = roomManager.getRoom(roomId);
+      if (!session) return;
+      if (payload.targetId) {
+        const controller = session.controllers.get(payload.targetId);
+        if (controller) {
+          io.to(controller.socketId).emit("server:signal", payload);
+        }
+      } else {
+        socket.to(roomId).emit("server:signal", payload);
+      }
+    });
+    socket.on("host:play_sound", (payload) => {
+      const { roomId, targetControllerId, soundId, volume, loop } = payload;
+      const session = roomManager.getRoom(roomId);
+      if (!session) return;
+      const message = { id: soundId, volume, loop };
+      if (targetControllerId) {
+        const controller = session.controllers.get(targetControllerId);
+        if (controller) {
+          io.to(controller.socketId).emit("server:playSound", message);
+        }
+      } else {
+        socket.to(roomId).emit("server:playSound", message);
+      }
+    });
+    socket.on("controller:play_sound", (payload) => {
+      const { roomId, soundId, volume, loop } = payload;
+      const session = roomManager.getRoom(roomId);
+      if (!session) return;
+      io.to(roomManager.getActiveHostId(session)).emit("server:playSound", {
+        id: soundId,
+        volume,
+        loop
+      });
+    });
+    socket.on("disconnect", () => {
+      const roomId = roomManager.getRoomByHostId(socket.id);
+      if (roomId) {
+        const session = roomManager.getRoom(roomId);
+        if (!session) {
+          roomManager.deleteHost(socket.id);
+          return;
+        }
+        if (socket.id === session.childHostSocketId) {
+          console.log(`[server] Game host disconnected from room ${roomId}`);
+          session.childHostSocketId = void 0;
+          session.focus = "SYSTEM";
+          session.joinToken = void 0;
+          session.activeControllerUrl = void 0;
+          io.to(roomId).emit("client:unloadUi");
+        } else if (socket.id === session.masterHostSocketId) {
+          console.log(`[server] Host disconnected from room ${roomId}`);
+          setTimeout(() => {
+            const currentSession = roomManager.getRoom(roomId);
+            if (currentSession && currentSession.masterHostSocketId === socket.id) {
+              console.log(`[server] Removing room ${roomId}`);
+              roomManager.removeRoom(roomId, io, "Host disconnected");
+            }
+          }, 3e3);
+        }
+        roomManager.deleteHost(socket.id);
+        return;
+      }
+      const controller = roomManager.getControllerInfo(socket.id);
+      if (controller) {
+        const session = roomManager.getRoom(controller.roomId);
+        if (session) {
+          session.controllers.delete(controller.controllerId);
+          const notice = {
+            controllerId: controller.controllerId
+          };
+          io.to(roomManager.getActiveHostId(session)).emit(
+            "server:controllerLeft",
+            notice
+          );
+        }
+        roomManager.deleteController(socket.id);
+      }
+    });
+  }
+);
+httpServer.listen(PORT, () => {
+  console.log(`[air-jam] server listening on http://localhost:${PORT}`);
+});
+//# sourceMappingURL=chunk-NWAVO5AJ.js.map