screeps-connectivity 0.2.0

package/src/stores/ServerStore.ts

@@ -0,0 +1,128 @@
+import { TypedStore } from './TypedStore.js'
+import type { Logger } from '../logger.js'
+import type { ServerStoreEvents } from '../types/events.js'
+import type { ServerVersion, ShardInfo, WorldInfo } from '../types/game.js'
+import type { HttpClient } from '../http/HttpClient.js'
+import type { SocketClient } from '../socket/SocketClient.js'
+import type { Cache } from '../cache/Cache.js'
+import type { Subscription } from '../subscription/index.js'
+
+export class ServerStore extends TypedStore<ServerStoreEvents> {
+  private readonly http: HttpClient
+  private readonly cache: Cache
+  private readonly socketSubs: Subscription[] = []
+  private _version: ServerVersion | null = null
+  get versionInfo(): ServerVersion | null { return this._version }
+  get isPrivateServer(): boolean | null {
+    if (!this._version) return null
+    return (this._version.serverData?.shards?.length ?? 0) === 0
+  }
+  private _shards: ShardInfo[] | null = null
+  get shardList(): ShardInfo[] | null { return this._shards }
+
+  constructor(http: HttpClient, socket: SocketClient, cache: Cache, logger?: Logger) {
+    super(logger)
+    this.http = http
+    this.cache = cache
+
+    this.socketSubs.push(socket.on('connected', () => {
+      this.emit('server:connected', {})
+    }))
+    this.socketSubs.push(socket.on('disconnected', (data) => {
+      const d = data as { willReconnect: boolean }
+      this.emit('server:disconnected', { willReconnect: d.willReconnect })
+    }))
+    this.socketSubs.push(socket.on('socket:error', (data) => {
+      this.emit('server:error', { error: data instanceof Error ? data : new Error(String(data)) })
+    }))
+  }
+
+  /** Release socket listeners owned by this store. Idempotent. */
+  destroy(): void {
+    for (const sub of this.socketSubs) sub.dispose()
+    this.socketSubs.length = 0
+  }
+
+  async version(): Promise<ServerVersion> {
+    const cached = this.cache.get<ServerVersion>('server/version')
+    if (cached) return cached
+    const res = await this.http.request<ServerVersion>('GET', '/api/version')
+    this._version = res
+    this.cache.set('server/version', res, 5 * 60_000)
+    this.emit('server:version', res)
+    return res
+  }
+
+  async refreshVersion(): Promise<ServerVersion> {
+    this.cache.delete('server/version')
+    return this.version()
+  }
+
+  async shards(): Promise<ShardInfo[]> {
+    const cached = this.cache.get<ShardInfo[]>('server/shards')
+    if (cached) return cached
+    const res = await this.http.request<{ ok: number; shards: ShardInfo[] }>('GET', '/api/game/shards/info')
+    this._shards = res.shards
+    this.cache.set('server/shards', res.shards, 5 * 60_000)
+    this.emit('server:shards', res.shards)
+    return res.shards
+  }
+
+  async refreshShards(): Promise<ShardInfo[]> {
+    this.cache.delete('server/shards')
+    return this.shards()
+  }
+
+  async worldInfo(shard?: string): Promise<WorldInfo> {
+    const shardKey = shard ?? 'default'
+    const cacheKey = `server/world/${shardKey}`
+    const cached = this.cache.get<WorldInfo>(cacheKey)
+    if (cached) return cached
+
+    const params: Record<string, string> = {}
+    if (shard) params.shard = shard
+
+    const size = await this.http.request<{ ok: number; width: number; height: number }>(
+      'GET', '/api/game/world-size', params
+    )
+    const { width, height } = size
+    this.logger.log(`worldInfo shard=${shard ?? 'none'} — raw size: ${width}x${height}`)
+
+    // Start with W/N-only assumption (most common for private servers)
+    // width/height = total rooms in that axis; W-only → all rooms are west of E0
+    let minX = -width, maxX = -1, minY = -height, maxY = -1
+
+    // Probe the four quadrant-origin rooms to detect which quadrants actually exist.
+    // mapStats only returns entries for rooms that exist on the server.
+    try {
+      const probe = await this.http.request<{ ok: number; stats: Record<string, unknown> }>(
+        'POST', '/api/game/map-stats',
+        { rooms: ['W0N0', 'E0N0', 'W0S0', 'E0S0'], statName: 'owner0', ...params }
+      )
+      const stats = probe.stats ?? {}
+      const found = (['W0N0', 'E0N0', 'W0S0', 'E0S0'] as const).filter(r => r in stats)
+      this.logger.log(`worldInfo corner probe — found: [${found.length ? found.join(', ') : 'none'}]`)
+      if ('E0N0' in stats || 'E0S0' in stats) {
+        // E quadrant exists: width spans both W and E sides, split evenly
+        minX = -Math.ceil(width / 2)
+        maxX = Math.floor(width / 2) - 1
+      }
+      if ('W0S0' in stats || 'E0S0' in stats) {
+        // S quadrant exists: height spans both N and S sides, split evenly
+        minY = -Math.ceil(height / 2)
+        maxY = Math.floor(height / 2) - 1
+      }
+    } catch (e) {
+      this.logger.log('worldInfo corner probe failed — keeping W/N defaults:', e)
+    }
+
+    this.logger.log(`worldInfo computed bounds — x: [${minX}, ${maxX}]  y: [${minY}, ${maxY}]`)
+    const info: WorldInfo = { shard: shard ?? null, width, height, minX, maxX, minY, maxY }
+    this.cache.set(cacheKey, info, 10 * 60_000)
+    return info
+  }
+
+  invalidateWorldInfo(shard?: string): void {
+    this.cache.delete(`server/world/${shard ?? 'default'}`)
+  }
+}

package/src/stores/TypedStore.ts

@@ -0,0 +1,31 @@
+import { Logger } from '../logger.js'
+import type { Subscription } from '../subscription/index.js'
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export class TypedStore<EventMap extends Record<string, any>> extends EventTarget {
+  protected readonly logger: Logger
+
+  constructor(logger?: Logger) {
+    super()
+    this.logger = logger ?? Logger.create()
+  }
+
+  emit<K extends string & keyof EventMap>(type: K, detail: EventMap[K]): void {
+    this.dispatchEvent(new CustomEvent(type, { detail }))
+  }
+
+  on<K extends string & keyof EventMap>(
+    type: K,
+    handler: (detail: EventMap[K]) => void,
+  ): Subscription {
+    this.logger.log(`on "${type}"`)
+    const listener = (e: Event) => handler((e as CustomEvent<EventMap[K]>).detail)
+    this.addEventListener(type, listener)
+    return {
+      dispose: () => {
+        this.logger.log(`off "${type}"`)
+        this.removeEventListener(type, listener)
+      },
+    }
+  }
+}

package/src/stores/UserStore.ts

@@ -0,0 +1,189 @@
+import { TypedStore } from './TypedStore.js'
+import type { Logger } from '../logger.js'
+import type { UserStoreEvents } from '../types/events.js'
+import type { UserInfo, CpuStats, ConsoleMessage, WorldStatus } from '../types/game.js'
+import type { HttpClient } from '../http/HttpClient.js'
+import type { SocketClient } from '../socket/SocketClient.js'
+import type { Cache } from '../cache/Cache.js'
+import type { Subscription } from '../subscription/index.js'
+
+export class UserStore extends TypedStore<UserStoreEvents> {
+  private readonly http: HttpClient
+  private readonly socket: SocketClient
+  private readonly cache: Cache
+  readonly console: ConsoleMessage[] = []
+  readonly maxConsoleSize: number
+  private _cpu: CpuStats | null = null
+  get cpu(): CpuStats | null { return this._cpu }
+  private _userInfo: UserInfo | null = null
+  get userInfo(): UserInfo | null { return this._userInfo }
+  private _userId: string | null = null
+  get userId(): string | null { return this._userId }
+  private _worldStatus: WorldStatus | null = null
+  get worldStatusValue(): WorldStatus | null { return this._worldStatus }
+  private _mePromise: Promise<UserInfo> | null = null
+
+  constructor(http: HttpClient, socket: SocketClient, cache: Cache, logger?: Logger, maxConsoleSize = 100) {
+    super(logger)
+    this.http = http
+    this.socket = socket
+    this.cache = cache
+    this.maxConsoleSize = maxConsoleSize
+  }
+
+  async me(): Promise<UserInfo> {
+    const cached = this.cache.get<UserInfo>('user/me')
+    if (cached) {
+      this._userId = cached._id
+      this._userInfo = cached
+      return cached
+    }
+    if (this._mePromise) {
+      return this._mePromise
+    }
+    this.logger.log('fetch me')
+    this._mePromise = this.http.auth.me().then((res) => {
+      const user = res as unknown as UserInfo
+      this._userId = user._id
+      this._userInfo = user
+      this.cache.set('user/me', user, 60_000)
+      this.emit('user:me', user)
+      return user
+    }).finally(() => {
+      this._mePromise = null
+    })
+    return this._mePromise
+  }
+
+  async refreshMe(): Promise<UserInfo> {
+    this.logger.log('refresh me')
+    this.cache.delete('user/me')
+    return this.me()
+  }
+
+  async worldStatus(): Promise<WorldStatus> {
+    const cached = this.cache.get<WorldStatus>('user/worldStatus')
+    if (cached) {
+      this._worldStatus = cached
+      return cached
+    }
+
+    this.logger.log('fetch world status')
+    const res = await this.http.user.worldStatus()
+    this._worldStatus = res.status
+    this.cache.set('user/worldStatus', res.status, 60_000)
+    this.emit('user:worldStatus', { status: res.status })
+    return res.status
+  }
+
+  async refreshWorldStatus(): Promise<WorldStatus> {
+    this.logger.log('refresh world status')
+    this.cache.delete('user/worldStatus')
+    return this.worldStatus()
+  }
+
+  subscribe(channel: 'console' | 'cpu' | 'code'): Subscription {
+    this.logger.log('subscribe', channel)
+    let socketSub: Subscription | null = null
+    let listenerSub: Subscription | null = null
+    let disposed = false
+
+    const setup = async () => {
+      try {
+        const uid = this._userId ?? (await this.me())._id
+        if (disposed) return
+        const fullChannel = `user:${uid}/${channel}`
+        socketSub = this.socket.subscribe(fullChannel)
+        listenerSub = this.socket.on(fullChannel, (data) => {
+          if (channel === 'cpu') {
+            this._cpu = data as CpuStats
+            this.emit('user:cpu', this._cpu)
+          } else if (channel === 'console') {
+            const raw = data as { messages?: ConsoleMessage, error?: string }
+            const msg: ConsoleMessage = {
+              log: raw.messages?.log ?? [],
+              results: raw.messages?.results ?? [],
+              error: raw.messages?.error ?? [],
+            }
+            if (raw.error) {
+              msg.error.push(raw.error)
+            }
+            this.console.push(msg)
+            if (this.console.length > this.maxConsoleSize) {
+              this.console.splice(0, this.console.length - this.maxConsoleSize)
+            }
+            this.emit('user:console', { messages: msg })
+          } else if (channel === 'code') {
+            this.emit('user:code', data as { branch: string; modules: Record<string, string> })
+          }
+        })
+      } catch (err) {
+        if (!disposed) {
+          this.dispatchEvent(new ErrorEvent('error', { error: err instanceof Error ? err : new Error(String(err)) }))
+        }
+      }
+    }
+
+    void setup()
+
+    return {
+      dispose: () => {
+        this.logger.log('unsubscribe', channel)
+        disposed = true
+        socketSub?.dispose()
+        listenerSub?.dispose()
+      },
+    }
+  }
+
+  /** Subscribe to the general user stream to receive global data like flags. */
+  subscribeUserStream(): Subscription {
+    this.logger.log('subscribe user stream')
+    let socketSub: Subscription | null = null
+    let listenerSub: Subscription | null = null
+    let disposed = false
+
+    const setup = async () => {
+      try {
+        const uid = this._userId ?? (await this.me())._id
+        if (disposed) return
+        const fullChannel = `user:${uid}`
+        socketSub = this.socket.subscribe(fullChannel)
+        listenerSub = this.socket.on(fullChannel, (data) => {
+          const payload = data as Record<string, unknown>
+          // Log flags received via user stream
+          if (payload && typeof payload === 'object' && 'flags' in payload) {
+            const flags = payload.flags as Record<string, unknown> | undefined
+            if (flags && typeof flags === 'object') {
+              for (const [name, flagData] of Object.entries(flags)) {
+                const fd = flagData as Record<string, unknown> | null
+                if (fd && typeof fd === 'object') {
+                  const room = fd.room ?? 'unknown'
+                  const x = fd.x ?? '?'
+                  const y = fd.y ?? '?'
+                  this.logger.log(`[flag:user] ${name} @ ${room} (${x},${y})`)
+                }
+              }
+            }
+          }
+          this.emit('user:stream', payload)
+        })
+      } catch (err) {
+        if (!disposed) {
+          this.dispatchEvent(new ErrorEvent('error', { error: err instanceof Error ? err : new Error(String(err)) }))
+        }
+      }
+    }
+
+    void setup()
+
+    return {
+      dispose: () => {
+        this.logger.log('unsubscribe user stream')
+        disposed = true
+        socketSub?.dispose()
+        listenerSub?.dispose()
+      },
+    }
+  }
+}

package/src/subscription/index.ts

@@ -0,0 +1,18 @@
+export interface Subscription {
+  dispose(): void
+}
+
+export class SubscriptionGroup implements Subscription {
+  private readonly subs: Subscription[] = []
+
+  add(sub: Subscription): void {
+    this.subs.push(sub)
+  }
+
+  dispose(): void {
+    for (const sub of this.subs) {
+      sub.dispose()
+    }
+    this.subs.length = 0
+  }
+}

package/src/types/api.ts

@@ -0,0 +1,252 @@
+export interface ApiOkResponse {
+  ok: number
+}
+
+export interface ApiAuthSigninResponse {
+  ok: number
+  token: string
+}
+
+export interface ApiAuthMeResponse {
+  ok: number
+  _id: string
+  email: string
+  username: string
+  cpu: number
+  gcl: number
+  credits: number
+  badge: import('./game.js').Badge
+  password: boolean
+}
+
+export interface ApiAuthQueryTokenResponse {
+  ok: number
+  token: { full: boolean }
+}
+
+export interface ApiAuthSteamTicketResponse {
+  ok: number
+  token: string
+  steamid: string
+}
+
+export interface ApiAuthModInfoResponse {
+  ok: number
+  name: string
+  version: string
+  allowRegistration: boolean
+  steam: boolean
+  github: boolean
+  gitlab: boolean
+}
+
+export interface ApiRegisterCheckResponse {
+  ok: number
+  error?: string
+}
+
+export interface ApiRoomTerrainResponse {
+  ok: number
+  terrain: Array<{
+    _id: string
+    room: string
+    terrain: string
+    type: string
+  }>
+}
+
+export interface ApiRoomObjectsResponse {
+  ok: number
+  objects: unknown[]
+  users: Record<string, unknown>
+}
+
+export interface ApiVersionResponse {
+  ok: number
+  package: number
+  protocol: number
+  users: number
+  serverData: {
+    historyChunkSize: number
+    features: Array<{ name: string }>
+    shards: string[]
+    customObjectTypes?: unknown
+  }
+}
+
+export interface ApiShardsInfoResponse {
+  ok: number
+  shards: Array<{
+    name: string
+    lastTicks: number[]
+    cpuLimit: number
+    rooms: number
+    users: number
+    tick: number
+  }>
+}
+
+export interface ApiUserBranchesResponse {
+  ok: number
+  list: Array<{
+    _id: string
+    branch: string
+    activeWorld: boolean
+    activeSim: boolean
+  }>
+}
+
+export interface ApiLeaderboardListResponse {
+  ok: number
+  list: Array<{ _id: string; season: string; user: string; score: number; rank: number }>
+  count: number
+  users: Record<string, { _id: string; username: string; badge: import('./game.js').Badge; gcl: number }>
+}
+
+export interface ApiLeaderboardSeasonsResponse {
+  ok: number
+  seasons: Array<{ _id: string; name: string; date: string }>
+}
+
+export interface ApiMapStatsRoomStat {
+  status: string
+  novice: number | null
+  respawnArea: number | null
+  openTime: number | null
+  own?: { user: string; level: number }
+  safeMode?: boolean
+  [mineral: `minerals${number}`]: { type: string; density: number } | undefined
+}
+
+export interface ApiMapStatsBadge {
+  type: number | { path1: string; path2: string }
+  color1: string
+  color2: string
+  color3: string
+  param?: number
+  flip: boolean
+}
+
+export interface ApiGameRoomsResponse {
+  ok: number
+  rooms: Array<{
+    _id: string
+    room: string
+    terrain: string
+  }>
+}
+
+export interface ApiMapStatsResponse {
+  ok: number
+  gameTime: number
+  stats: Record<string, ApiMapStatsRoomStat>
+  statsMax: Record<string, unknown>
+  users: Record<string, { _id: string; username: string; badge: ApiMapStatsBadge }>
+}
+
+export interface ApiCreateFlagResponse {
+  ok: number
+  name?: string
+  error?: string
+}
+
+export interface ApiGenUniqueFlagNameResponse {
+  ok: number
+  name: string
+}
+
+export interface ApiCheckUniqueFlagNameResponse {
+  ok: number
+  error?: string
+}
+
+export interface ApiChangeFlagColorResponse {
+  ok: number
+}
+
+export interface ApiRemoveFlagResponse {
+  ok: number
+}
+
+export interface ApiGenUniqueObjectNameResponse {
+  ok: number
+  name: string
+}
+
+export interface ApiCheckUniqueObjectNameResponse {
+  ok: number
+  error?: string
+}
+
+export interface ApiGameTickResponse {
+  ok: number
+  tick: number
+}
+
+export interface ApiPowerCreep {
+  _id: string
+  name: string
+  className: string
+  level: number
+  powers: Record<string, { level: number; cooldownTime?: number }>
+  deleteTime?: number
+}
+
+export interface ApiPowerCreepsListResponse {
+  ok: number
+  list: ApiPowerCreep[]
+}
+
+export interface ApiUserFindResponse {
+  ok: number
+  user: {
+    _id: string
+    username: string
+    badge: import('./game.js').Badge
+    gcl: number
+  }
+}
+
+export interface ApiUserMoneyHistoryResponse {
+  ok: number
+  page: number
+  list: Array<{
+    _id: string
+    date: string
+    tick: number
+    type: string
+    balance: number
+    change: number
+    market?: unknown
+  }>
+}
+
+export interface ApiUserMessage {
+  _id: string
+  date: string
+  respondent: string
+  user: string
+  text: string
+  unread: boolean
+}
+
+export interface ApiUserMessagesListResponse {
+  ok: number
+  messages: ApiUserMessage[]
+}
+
+export interface ApiUserMessagesIndexEntry {
+  _id: string
+  message: ApiUserMessage
+  user: { _id: string; username: string; badge: import('./game.js').Badge }
+}
+
+export interface ApiUserMessagesIndexResponse {
+  ok: number
+  list: ApiUserMessagesIndexEntry[]
+}
+
+export interface ApiUserMessagesUnreadCountResponse {
+  ok: number
+  count: number
+}

package/src/types/events.ts

@@ -0,0 +1,72 @@
+import type {
+    ConsoleMessage,
+    CpuStats,
+    RoomMap2Data,
+    RoomObjectDiff,
+    RoomObjectMap,
+    RoomTerrain,
+    ServerVersion,
+    ShardInfo,
+    UserInfo,
+    WorldStatus
+} from './game.js'
+import type {MapStatsRoomData} from '../stores/MapStatsStore.js'
+
+export interface RoomStoreEvents {
+    'room:update': {
+        room: string;
+        shard: string | null;
+        gameTime: number | undefined;
+        objects: RoomObjectMap;
+        diff: RoomObjectDiff;
+        visual: string;
+        users?: Record<string, { _id: string; username: string }>
+    }
+    'room:terrainavailable': { room: string; shard: string | null; terrain: RoomTerrain }
+    'room:error': { room: string; shard: string | null; message: string }
+}
+
+export type Map2SubscriptionStatus = 'pending' | 'active'
+
+export interface MapStoreEvents {
+    'room:map2update': { room: string; shard: string | null; data: RoomMap2Data; source: 'cache' | 'live' }
+    'room:map2state': { room: string; shard: string | null; status: Map2SubscriptionStatus }
+}
+
+export interface UserStoreEvents {
+    'user:me': UserInfo
+    'user:worldStatus': { status: WorldStatus }
+    'user:cpu': CpuStats
+    'user:console': { messages: ConsoleMessage }
+    'user:code': { branch: string; modules: Record<string, string> }
+    'user:stream': Record<string, unknown>
+}
+
+export interface ServerStoreEvents {
+    'server:connected': Record<string, never>
+    'server:disconnected': { willReconnect: boolean }
+    'server:error': { error: Error }
+    'server:version': ServerVersion
+    'server:shards': ShardInfo[]
+}
+
+export interface MapStatsStoreEvents {
+    'mapStats:room': { room: string; shard: string | null; stat: MapStatsRoomData }
+}
+
+export interface HttpClientEvents {
+    'http:success': {
+        method: string
+        path: string
+        status: number
+    }
+    'http:error': {
+        method: string
+        path: string
+        status: number
+        error: Error
+    }
+    'http:tokenRefresh': {
+        token: string
+    }
+}