@rpgjs/server 5.0.0-alpha.9 → 5.0.0-beta.1

package/src/node/connection.ts

@@ -0,0 +1,254 @@
+import type { RpgWebSocketConnection } from "./types";
+
+type RuntimeProcess = {
+  env?: Record<string, string | undefined>;
+};
+
+function readEnvVariable(name: string): string | undefined {
+  const value = (globalThis as { process?: RuntimeProcess }).process?.env?.[name];
+  return typeof value === "string" ? value : undefined;
+}
+
+export class PartyConnection {
+  public id: string;
+  public uri: string;
+  private _state: any = {};
+  private messageQueue: Array<{ message: string; timestamp: number; sequence: number }> = [];
+  private isProcessingQueue = false;
+  private sequenceCounter = 0;
+  private incomingQueue: Array<{
+    message: string;
+    timestamp: number;
+    processor: (messages: string[]) => Promise<void>;
+  }> = [];
+  private isProcessingIncomingQueue = false;
+
+  public static packetLossRate = parseFloat(readEnvVariable("RPGJS_PACKET_LOSS_RATE") || "0.1");
+  public static packetLossEnabled = readEnvVariable("RPGJS_ENABLE_PACKET_LOSS") === "true";
+  public static packetLossFilter = readEnvVariable("RPGJS_PACKET_LOSS_FILTER") || "";
+  public static bandwidthEnabled = readEnvVariable("RPGJS_ENABLE_BANDWIDTH") === "true";
+  public static bandwidthKbps = parseInt(readEnvVariable("RPGJS_BANDWIDTH_KBPS") || "100");
+  public static bandwidthFilter = readEnvVariable("RPGJS_BANDWIDTH_FILTER") || "";
+  public static latencyEnabled = readEnvVariable("RPGJS_ENABLE_LATENCY") === "true";
+  public static latencyMs = parseInt(readEnvVariable("RPGJS_LATENCY_MS") || "50");
+  public static latencyFilter = readEnvVariable("RPGJS_LATENCY_FILTER") || "";
+
+  constructor(private ws: RpgWebSocketConnection, id?: string, uri?: string) {
+    this.id = id || this.generateId();
+    this.uri = uri || "";
+  }
+
+  private generateId(): string {
+    return `conn_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+  }
+
+  async send(data: any): Promise<void> {
+    if (this.ws.readyState !== 1) {
+      return;
+    }
+
+    const message = typeof data === "string" ? data : JSON.stringify(data);
+    const timestamp = Date.now();
+    const sequence = ++this.sequenceCounter;
+
+    this.messageQueue.push({ message, timestamp, sequence });
+
+    if (!this.isProcessingQueue) {
+      void this.processMessageQueue();
+    }
+  }
+
+  private async processMessageQueue(): Promise<void> {
+    if (this.isProcessingQueue) {
+      return;
+    }
+    this.isProcessingQueue = true;
+
+    while (this.messageQueue.length > 0) {
+      const queueItem = this.messageQueue.shift()!;
+
+      if (this.shouldApplyLatency(queueItem.message)) {
+        await this.waitUntil(queueItem.timestamp + PartyConnection.latencyMs);
+      }
+
+      if (PartyConnection.bandwidthEnabled && PartyConnection.bandwidthKbps > 0) {
+        if (!PartyConnection.bandwidthFilter || queueItem.message.includes(PartyConnection.bandwidthFilter)) {
+          const messageSizeBits = queueItem.message.length * 8;
+          const transmissionTimeMs = (messageSizeBits / (PartyConnection.bandwidthKbps * 1000)) * 1000;
+          const bandwidthDelayMs = Math.max(transmissionTimeMs, 10);
+          console.log(
+            `\x1b[34m[BANDWIDTH SIMULATION]\x1b[0m Connection ${this.id}: Message #${queueItem.sequence} transmission time: ${bandwidthDelayMs.toFixed(1)}ms`,
+          );
+          await new Promise((resolve) => setTimeout(resolve, bandwidthDelayMs));
+        }
+      }
+
+      this.ws.send(queueItem.message);
+    }
+
+    this.isProcessingQueue = false;
+  }
+
+  private shouldApplyLatency(message: string): boolean {
+    if (!PartyConnection.latencyEnabled || PartyConnection.latencyMs <= 0) {
+      return false;
+    }
+    if (!PartyConnection.latencyFilter) {
+      return true;
+    }
+    return message.includes(PartyConnection.latencyFilter);
+  }
+
+  private async waitUntil(targetTimestamp: number): Promise<void> {
+    const delayMs = targetTimestamp - Date.now();
+    if (delayMs <= 0) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+  }
+
+  close(): void {
+    if (this.ws.readyState === 1) {
+      this.ws.close();
+    }
+  }
+
+  setState(value: any): void {
+    this._state = value;
+  }
+
+  get state(): any {
+    return this._state;
+  }
+
+  bufferIncoming(message: string, processor: (messages: string[]) => Promise<void>): void {
+    this.incomingQueue.push({
+      message,
+      timestamp: Date.now(),
+      processor,
+    });
+
+    if (!this.isProcessingIncomingQueue) {
+      void this.processIncomingQueue();
+    }
+  }
+
+  private async processIncomingQueue(): Promise<void> {
+    if (this.isProcessingIncomingQueue) {
+      return;
+    }
+    this.isProcessingIncomingQueue = true;
+
+    while (this.incomingQueue.length > 0) {
+      const item = this.incomingQueue.shift()!;
+      if (this.shouldApplyLatency(item.message)) {
+        await this.waitUntil(item.timestamp + PartyConnection.latencyMs);
+      }
+      try {
+        await item.processor([item.message]);
+      } catch (err) {
+        console.error("Error processing incoming message:", err);
+      }
+    }
+
+    this.isProcessingIncomingQueue = false;
+  }
+
+  static configurePacketLoss(enabled: boolean, rate: number, filter?: string): void {
+    PartyConnection.packetLossEnabled = enabled;
+    PartyConnection.packetLossRate = Math.max(0, Math.min(1, rate));
+    PartyConnection.packetLossFilter = filter || "";
+
+    if (enabled && rate > 0) {
+      const filterInfo = filter ? ` (filtered: "${filter}")` : "";
+      console.log(`\x1b[35m[PACKET LOSS SIMULATION]\x1b[0m Enabled with ${(rate * 100).toFixed(1)}% loss rate${filterInfo}`);
+    } else if (enabled) {
+      console.log("\x1b[35m[PACKET LOSS SIMULATION]\x1b[0m Enabled but rate is 0% (no messages will be dropped)");
+    } else {
+      console.log("\x1b[35m[PACKET LOSS SIMULATION]\x1b[0m Disabled");
+    }
+  }
+
+  static getPacketLossStatus(): { enabled: boolean; rate: number; filter: string } {
+    return {
+      enabled: PartyConnection.packetLossEnabled,
+      rate: PartyConnection.packetLossRate,
+      filter: PartyConnection.packetLossFilter,
+    };
+  }
+
+  static configureBandwidth(enabled: boolean, kbps: number, filter?: string): void {
+    PartyConnection.bandwidthEnabled = enabled;
+    PartyConnection.bandwidthKbps = Math.max(1, kbps);
+    PartyConnection.bandwidthFilter = filter || "";
+
+    if (enabled && kbps > 0) {
+      const filterInfo = filter ? ` (filtered: "${filter}")` : "";
+      console.log(`\x1b[35m[BANDWIDTH SIMULATION]\x1b[0m Enabled with ${kbps} kbps bandwidth${filterInfo}`);
+    } else if (enabled) {
+      console.log("\x1b[35m[BANDWIDTH SIMULATION]\x1b[0m Enabled but bandwidth is 0 kbps (no delay will be applied)");
+    } else {
+      console.log("\x1b[35m[BANDWIDTH SIMULATION]\x1b[0m Disabled");
+    }
+  }
+
+  static getBandwidthStatus(): { enabled: boolean; kbps: number; filter: string } {
+    return {
+      enabled: PartyConnection.bandwidthEnabled,
+      kbps: PartyConnection.bandwidthKbps,
+      filter: PartyConnection.bandwidthFilter,
+    };
+  }
+
+  static configureLatency(enabled: boolean, ms: number, filter?: string): void {
+    PartyConnection.latencyEnabled = enabled;
+    PartyConnection.latencyMs = Math.max(0, ms);
+    PartyConnection.latencyFilter = filter || "";
+
+    if (enabled && ms > 0) {
+      const filterInfo = filter ? ` (filtered: "${filter}")` : "";
+      console.log(`\x1b[35m[LATENCY SIMULATION]\x1b[0m Enabled with ${ms}ms fixed latency${filterInfo}`);
+    } else if (enabled) {
+      console.log("\x1b[35m[LATENCY SIMULATION]\x1b[0m Enabled but latency is 0ms (no delay will be applied)");
+    } else {
+      console.log("\x1b[35m[LATENCY SIMULATION]\x1b[0m Disabled");
+    }
+  }
+
+  static getLatencyStatus(): { enabled: boolean; ms: number; filter: string } {
+    return {
+      enabled: PartyConnection.latencyEnabled,
+      ms: PartyConnection.latencyMs,
+      filter: PartyConnection.latencyFilter,
+    };
+  }
+}
+
+export function logNetworkSimulationStatus(): void {
+  const packetLossStatus = PartyConnection.getPacketLossStatus();
+  const bandwidthStatus = PartyConnection.getBandwidthStatus();
+  const latencyStatus = PartyConnection.getLatencyStatus();
+
+  if (packetLossStatus.enabled) {
+    const filterInfo = packetLossStatus.filter ? ` (filter: "${packetLossStatus.filter}")` : "";
+    console.log(
+      `\x1b[36m[NETWORK SIMULATION]\x1b[0m Packet loss simulation: ${(packetLossStatus.rate * 100).toFixed(1)}% loss rate${filterInfo}`,
+    );
+  } else {
+    console.log("\x1b[36m[NETWORK SIMULATION]\x1b[0m Packet loss simulation: disabled");
+  }
+
+  if (bandwidthStatus.enabled) {
+    const filterInfo = bandwidthStatus.filter ? ` (filter: "${bandwidthStatus.filter}")` : "";
+    console.log(`\x1b[36m[NETWORK SIMULATION]\x1b[0m Bandwidth simulation: ${bandwidthStatus.kbps} kbps${filterInfo}`);
+  } else {
+    console.log("\x1b[36m[NETWORK SIMULATION]\x1b[0m Bandwidth simulation: disabled");
+  }
+
+  if (latencyStatus.enabled) {
+    const filterInfo = latencyStatus.filter ? ` (filter: "${latencyStatus.filter}")` : "";
+    console.log(`\x1b[36m[NETWORK SIMULATION]\x1b[0m Latency simulation: ${latencyStatus.ms}ms ping${filterInfo}`);
+  } else {
+    console.log("\x1b[36m[NETWORK SIMULATION]\x1b[0m Latency simulation: disabled");
+  }
+}

package/src/node/index.ts

@@ -0,0 +1,22 @@
+export { PartyConnection, logNetworkSimulationStatus } from "./connection";
+export {
+  createMapUpdateHeaders,
+  isMapUpdateAuthorized,
+  MAP_UPDATE_TOKEN_ENV,
+  MAP_UPDATE_TOKEN_HEADER,
+  readMapUpdateToken,
+  resolveMapUpdateToken,
+} from "./map";
+export { PartyRoom } from "./room";
+export { createRpgServerTransport, RpgServerTransport } from "./transport";
+export type {
+  CreateRpgServerTransportOptions,
+  HandleNodeRequestOptions,
+  RpgTransportRequestLike,
+  RpgTransportServer,
+  RpgTransportServerConstructor,
+  RpgWebSocketConnection,
+  RpgWebSocketRequestLike,
+  RpgWebSocketServer,
+  SendMapUpdateOptions,
+} from "./types";

package/src/node/map.ts

@@ -0,0 +1,328 @@
+import type { RpgTransportServer } from "./types";
+
+interface ResolveMapOptions {
+  host?: string;
+  headers?: Headers;
+  mapUpdateToken?: string;
+  tiledBasePaths?: string[];
+}
+
+export const MAP_UPDATE_TOKEN_HEADER = "x-rpgjs-map-update-token";
+export const MAP_UPDATE_TOKEN_ENV = "RPGJS_MAP_UPDATE_TOKEN";
+
+type RuntimeProcess = {
+  cwd?: () => string;
+  env?: Record<string, string | undefined>;
+};
+
+function getRuntimeProcess(): RuntimeProcess | undefined {
+  return (globalThis as { process?: RuntimeProcess }).process;
+}
+
+function readEnvVariable(name: string): string | undefined {
+  const value = getRuntimeProcess()?.env?.[name];
+  return typeof value === "string" ? value : undefined;
+}
+
+function getWorkingDirectory(): string | undefined {
+  const cwd = getRuntimeProcess()?.cwd;
+  if (typeof cwd !== "function") {
+    return undefined;
+  }
+
+  try {
+    return cwd();
+  } catch {
+    return undefined;
+  }
+}
+
+function normalizeRoomMapId(roomId: string): string {
+  return roomId.startsWith("map-") ? roomId.slice(4) : roomId;
+}
+
+function toBasePathPrefix(basePath: string): string {
+  const trimmed = basePath.trim();
+  if (!trimmed) {
+    return "";
+  }
+  return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+}
+
+function extractFileLikeMapDefinition(maps: any[], mapId: string): any | null {
+  for (const mapDef of maps) {
+    if (typeof mapDef === "object" && mapDef) {
+      const candidateId = typeof mapDef.id === "string" ? mapDef.id.replace(/^map-/, "") : "";
+      if (candidateId === mapId) {
+        return mapDef;
+      }
+      continue;
+    }
+
+    if (typeof mapDef === "string") {
+      const fileName = mapDef.split("/").pop()?.replace(/\.tmx$/i, "");
+      if (fileName === mapId) {
+        return { id: mapId, file: mapDef };
+      }
+    }
+  }
+
+  return null;
+}
+
+async function fetchTextByUrl(url: string): Promise<string | null> {
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      return null;
+    }
+    return await response.text();
+  } catch {
+    return null;
+  }
+}
+
+async function readTextByFilePath(pathLike: string): Promise<string | null> {
+  try {
+    const { readFile } = await import("node:fs/promises");
+    const { isAbsolute, join } = await import("node:path");
+
+    const cwd = getWorkingDirectory();
+    const candidates = isAbsolute(pathLike) || !cwd ? [pathLike] : [pathLike, join(cwd, pathLike)];
+
+    for (const candidate of candidates) {
+      try {
+        return await readFile(candidate, "utf8");
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    return null;
+  }
+
+  return null;
+}
+
+function getTiledBasePaths(paths?: string[]): string[] {
+  const values = [
+    ...(paths || []),
+    readEnvVariable("RPGJS_TILED_BASE_PATH"),
+    "map",
+    "data",
+    "assets/data",
+    "assets/map",
+  ].filter((value): value is string => !!value);
+
+  return Array.from(new Set(values));
+}
+
+export function resolveMapUpdateToken(explicitToken?: string): string {
+  return explicitToken ?? readEnvVariable(MAP_UPDATE_TOKEN_ENV) ?? "";
+}
+
+export function createMapUpdateHeaders(
+  token?: string,
+  init?: HeadersInit,
+): Headers {
+  const headers = new Headers(init);
+  if (!headers.has("content-type")) {
+    headers.set("content-type", "application/json");
+  }
+  const resolvedToken = resolveMapUpdateToken(token);
+  if (resolvedToken) {
+    headers.set(MAP_UPDATE_TOKEN_HEADER, resolvedToken);
+  }
+  return headers;
+}
+
+export function readMapUpdateToken(headers: Headers): string {
+  const directToken = headers.get(MAP_UPDATE_TOKEN_HEADER);
+  if (directToken) {
+    return directToken;
+  }
+
+  const authorization = headers.get("authorization");
+  if (!authorization) {
+    return "";
+  }
+
+  const [scheme, value] = authorization.split(/\s+/, 2);
+  if (scheme?.toLowerCase() !== "bearer" || !value) {
+    return "";
+  }
+
+  return value.trim();
+}
+
+export function isMapUpdateAuthorized(headers: Headers, expectedToken?: string): boolean {
+  const requiredToken = resolveMapUpdateToken(expectedToken);
+  if (!requiredToken) {
+    return true;
+  }
+  return readMapUpdateToken(headers) === requiredToken;
+}
+
+async function resolveMapDocument(
+  mapId: string,
+  mapDefinition: any,
+  options: ResolveMapOptions,
+): Promise<{ xml: string; sourceUrl?: string }> {
+  if (typeof mapDefinition?.data === "string" && mapDefinition.data.includes("<map")) {
+    return { xml: mapDefinition.data };
+  }
+
+  if (typeof mapDefinition?.file === "string") {
+    const file = mapDefinition.file.trim();
+    if (file.includes("<map")) {
+      return { xml: file };
+    }
+    if (/^https?:\/\//i.test(file)) {
+      const xml = await fetchTextByUrl(file);
+      if (xml) {
+        return { xml, sourceUrl: file };
+      }
+    }
+    if (file.startsWith("/") && options.host) {
+      const sourceUrl = `http://${options.host}${file}`;
+      const xml = await fetchTextByUrl(sourceUrl);
+      if (xml) {
+        return { xml, sourceUrl };
+      }
+    }
+    const xmlFromFile = await readTextByFilePath(file);
+    if (xmlFromFile) {
+      return { xml: xmlFromFile };
+    }
+  }
+
+  if (options.host) {
+    for (const basePath of getTiledBasePaths(options.tiledBasePaths)) {
+      const prefix = toBasePathPrefix(basePath);
+      const sourceUrl = `http://${options.host}${prefix}/${mapId}.tmx`;
+      const xml = await fetchTextByUrl(sourceUrl);
+      if (xml) {
+        return { xml, sourceUrl };
+      }
+    }
+  }
+
+  return { xml: "" };
+}
+
+export async function enrichMapWithParsedTiledData(payload: any, options: ResolveMapOptions = {}): Promise<void> {
+  if (payload?.parsedMap || typeof payload?.id !== "string") {
+    return;
+  }
+
+  const maps = Array.isArray(payload.__maps) ? payload.__maps : [];
+  const mapDefinition = extractFileLikeMapDefinition(maps, payload.id);
+  const mapDoc = await resolveMapDocument(payload.id, mapDefinition, options);
+  if (!mapDoc.xml) {
+    return;
+  }
+
+  try {
+    const tiledModuleName = "@canvasengine/tiled";
+    const tiledModule = await import(/* @vite-ignore */ tiledModuleName);
+    const TiledParser = tiledModule?.TiledParser;
+    if (!TiledParser) {
+      return;
+    }
+
+    const mapParser = new TiledParser(mapDoc.xml);
+    const parsedMap = mapParser.parseMap();
+    const tilesets = Array.isArray(parsedMap?.tilesets) ? parsedMap.tilesets : [];
+    const mergedTilesets: any[] = [];
+
+    for (const tileset of tilesets) {
+      if (!tileset?.source) {
+        mergedTilesets.push(tileset);
+        continue;
+      }
+
+      let tilesetUrl: string | undefined;
+      if (mapDoc.sourceUrl) {
+        try {
+          tilesetUrl = new URL(tileset.source, mapDoc.sourceUrl).toString();
+        } catch {
+          tilesetUrl = undefined;
+        }
+      } else if (options.host) {
+        const prefix = toBasePathPrefix(getTiledBasePaths(options.tiledBasePaths)[0] || "map");
+        const candidatePath = tileset.source.startsWith("/")
+          ? tileset.source
+          : `${prefix}/${tileset.source}`.replace(/\/{2,}/g, "/");
+        tilesetUrl = `http://${options.host}${candidatePath.startsWith("/") ? candidatePath : `/${candidatePath}`}`;
+      }
+
+      const tilesetRaw = tilesetUrl
+        ? await fetchTextByUrl(tilesetUrl)
+        : await readTextByFilePath(tileset.source);
+
+      if (!tilesetRaw) {
+        mergedTilesets.push(tileset);
+        continue;
+      }
+
+      try {
+        const tilesetParser = new TiledParser(tilesetRaw);
+        const parsedTileset = tilesetParser.parseTileset();
+        mergedTilesets.push({
+          ...tileset,
+          ...parsedTileset,
+        });
+      } catch {
+        mergedTilesets.push(tileset);
+      }
+    }
+
+    parsedMap.tilesets = mergedTilesets;
+    payload.data = mapDoc.xml;
+    payload.parsedMap = parsedMap;
+
+    if (typeof parsedMap?.width === "number" && typeof parsedMap?.tilewidth === "number") {
+      payload.width = parsedMap.width * parsedMap.tilewidth;
+    }
+    if (typeof parsedMap?.height === "number" && typeof parsedMap?.tileheight === "number") {
+      payload.height = parsedMap.height * parsedMap.tileheight;
+    }
+  } catch {
+    return;
+  }
+}
+
+export async function updateMap(roomId: string, rpgServer: RpgTransportServer, options: ResolveMapOptions = {}): Promise<void> {
+  if (!roomId.startsWith("map-")) {
+    return;
+  }
+
+  try {
+    const mapId = normalizeRoomMapId(roomId);
+    const serverMaps = Array.isArray(rpgServer.maps) ? rpgServer.maps : [];
+    const defaultMapPayload: any = {
+      id: mapId,
+      width: 0,
+      height: 0,
+      events: [],
+      __maps: serverMaps,
+    };
+
+    await enrichMapWithParsedTiledData(defaultMapPayload, options);
+    delete defaultMapPayload.__maps;
+
+    const headers = createMapUpdateHeaders(options.mapUpdateToken, options.headers);
+
+    await rpgServer.onRequest?.({
+      url: `http://localhost/parties/main/${roomId}/map/update`,
+      method: "POST",
+      headers,
+      json: async () => defaultMapPayload,
+      text: async () => JSON.stringify(defaultMapPayload),
+    });
+
+    console.log(`Initialized map for room ${roomId} via POST /map/update`);
+  } catch (error) {
+    console.warn(`Failed initializing map for room ${roomId}:`, error);
+  }
+}

package/src/node/room.ts

@@ -0,0 +1,63 @@
+import { PartyConnection } from "./connection";
+
+export class PartyRoom {
+  public id: string;
+  public internalID: string;
+  public env: Record<string, any> = {};
+  public context: any = {};
+
+  private connections = new Map<string, PartyConnection>();
+  private storageData = new Map<string, any>();
+
+  constructor(id: string) {
+    this.id = id;
+    this.internalID = `internal_${id}_${Date.now()}`;
+  }
+
+  async broadcast(message: any, except: string[] = []): Promise<void> {
+    const data = typeof message === "string" ? message : JSON.stringify(message);
+    const sendPromises: Promise<void>[] = [];
+
+    for (const [connectionId, connection] of this.connections) {
+      if (!except.includes(connectionId)) {
+        sendPromises.push(connection.send(data));
+      }
+    }
+
+    await Promise.all(sendPromises);
+  }
+
+  getConnection(id: string): PartyConnection | undefined {
+    return this.connections.get(id);
+  }
+
+  getConnections(tag?: string): IterableIterator<PartyConnection> {
+    void tag;
+    return this.connections.values();
+  }
+
+  addConnection(connection: PartyConnection): void {
+    this.connections.set(connection.id, connection);
+  }
+
+  removeConnection(connectionId: string): void {
+    this.connections.delete(connectionId);
+  }
+
+  get storage() {
+    return {
+      put: async (key: string, value: any) => {
+        this.storageData.set(key, value);
+      },
+      get: async <T = any>(key: string): Promise<T | undefined> => {
+        return this.storageData.get(key) as T;
+      },
+      delete: async (key: string) => {
+        this.storageData.delete(key);
+      },
+      list: async () => {
+        return Array.from(this.storageData.entries());
+      },
+    };
+  }
+}