screeps-connectivity 0.5.2 → 0.7.0

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 0.7.0
+
+### Minor Changes
+
+- 69d132d: Add an account Overview page (GCL/GPL rings, lifetime stats, per-room minimap previews) and a public Profile page with routing between them; optional dashboard endpoints (`user/overview`, `user/rooms`) now fail silently on servers that don't implement them.
+
+## 0.6.0
+
+### Minor Changes
+
+- 71ce50f: Show reservation vs. owner, RCL, and the controller sign in the world-map tooltip.
+- f525f2b: Replace the top-right logout button with a username chip (badge + name) that opens an account dropdown. The dropdown holds Settings, Respawn (with a destructive confirmation dialog), Change/Set password, and Logout. Password management works for email/password and Steam sessions — Steam-only accounts without a password get a "Set password" flow — while pasted API-token and guest sessions hide it. Settings now opens from the dropdown (guests keep the header gear); the panel's existing close button is the only toggle. Trimmed the Settings panel of options already available directly in the room/map views (creep labels, map view options) and removed the "Verbose creep details" toggle — the body-part breakdown is now always shown.
+
+  `screeps-connectivity`: `UserInfo` gains an optional `password?: boolean` field, surfaced from `/api/auth/me`, indicating whether the account has a password set.
+
+### Patch Changes
+
+- 270fabf: Deep-merge room-object diffs so structure stores keep non-energy resources across ticks.
+
 ## 0.5.2
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "screeps-connectivity",
-  "version": "0.5.2",
+  "version": "0.7.0",
   "license": "ISC",
   "type": "module",
   "repository": {

package/src/http/HttpClient.ts

@@ -16,6 +16,14 @@ export interface RateLimitInfo {
   reset: number
 }
 
+export interface RequestOptions {
+  /** Internal: marks the post-auth retry so a second 401 doesn't loop. */
+  isRetry?: boolean
+  /** Suppress user-facing surfacing of failures (the http:error event carries the
+   *  flag through). Use for optional endpoints the caller handles gracefully. */
+  silent?: boolean
+}
+
 export class HttpClient extends EventTarget {
   readonly baseUrl: string
   private readonly authStrategy: AuthStrategy
@@ -79,7 +87,7 @@ export class HttpClient extends EventTarget {
     this.token = token
   }
 
-  async request<T>(method: string, path: string, body?: Record<string, unknown>, isRetry = false): Promise<T> {
+  async request<T>(method: string, path: string, body?: Record<string, unknown>, opts: RequestOptions = {}): Promise<T> {
     this.logger.log(method, path)
     const url = new URL(path.startsWith('/') ? path.slice(1) : path, this.baseUrl)
     const headers: Record<string, string> = {}
@@ -115,9 +123,9 @@ export class HttpClient extends EventTarget {
 
     this.updateRateLimit(path, res)
 
-    if (res.status === 401 && !isRetry && !this.authenticating) {
+    if (res.status === 401 && !opts.isRetry && !this.authenticating) {
       await this.authenticate()
-      return this.request<T>(method, path, body, true)
+      return this.request<T>(method, path, body, { ...opts, isRetry: true })
     }
 
     // 304: some servers (e.g. private Screeps) send a body with 304 — treat it as success
@@ -125,7 +133,7 @@ export class HttpClient extends EventTarget {
       let body = ''
       try { body = await res.text() } catch { /* ignore */ }
       const error = new Error(`HTTP ${res.status}: ${body}`)
-      this.emit('http:error', { method, path, status: res.status, error })
+      this.emit('http:error', { method, path, status: res.status, error, silent: opts.silent })
       throw error
     }
 
@@ -135,7 +143,7 @@ export class HttpClient extends EventTarget {
 
     if (typeof data['error'] === 'string') {
       const error = new Error(`Screeps API error: ${data['error']}`)
-      this.emit('http:error', { method, path, status: res.status, error })
+      this.emit('http:error', { method, path, status: res.status, error, silent: opts.silent })
       throw error
     }
 

package/src/http/endpoints/user.ts

@@ -3,6 +3,8 @@ import type {
   ApiUserBranchesResponse,
   ApiUserFindResponse,
   ApiUserMoneyHistoryResponse,
+  ApiUserOverviewResponse,
+  ApiUserRoomsResponse,
 } from '../../types/api.js'
 import { createUserMessagesEndpoints, type UserMessagesEndpoints } from './user-messages.js'
 
@@ -30,8 +32,8 @@ export interface UserEndpoints {
   }
   console(expression: string, shard?: string | null): Promise<unknown>
   stats(interval: number): Promise<unknown>
-  rooms(id: string): Promise<unknown>
-  overview(interval: number, statName: string): Promise<unknown>
+  rooms(id: string): Promise<ApiUserRoomsResponse>
+  overview(interval: number, statName: string): Promise<ApiUserOverviewResponse>
   worldStatus(): Promise<{ ok: number; status: 'normal' | 'lost' | 'empty' }>
   worldStartRoom(shard?: string | null): Promise<unknown>
   find(query: { username: string } | { id: string }): Promise<ApiUserFindResponse>
@@ -73,8 +75,11 @@ export function createUserEndpoints(http: HttpClient): UserEndpoints {
     },
     console: (expression, shard) => http.request('POST', '/api/user/console', withShard({ expression }, shard)),
     stats: (interval) => http.request('GET', '/api/user/stats', { interval }),
-    rooms: (id) => http.request('GET', '/api/user/rooms', { id }),
-    overview: (interval, statName) => http.request('GET', '/api/user/overview', { interval, statName }),
+    // Best-effort dashboard data: not every server implements these, and the
+    // Overview page degrades gracefully (zeros / no tiles), so a failure here
+    // shouldn't raise a user-facing error toast — mark them silent.
+    rooms: (id) => http.request('GET', '/api/user/rooms', { id }, { silent: true }),
+    overview: (interval, statName) => http.request('GET', '/api/user/overview', { interval, statName }, { silent: true }),
     worldStatus: () => http.request('GET', '/api/user/world-status'),
     worldStartRoom: (shard) => http.request('GET', '/api/user/world-start-room', withShard({}, shard)),
     find: (query) => http.request('GET', '/api/user/find', query as Record<string, unknown>),

package/src/index.ts

@@ -40,7 +40,7 @@ export type {
 
 export { fetchServerVersion, fetchAuthModInfo, checkUsername, checkEmail, registerUser, getServerFeature, getScreepsmodAuth } from './http/fetchServerVersion.js'
 export type { ApiAuthModInfoResponse } from './http/fetchServerVersion.js'
-export type { RoomHistoryChunk, ApiRoomDecorationsResponse, ApiRoomDecorationItem, ApiRoomDecorationDef, ApiRoomDecorationGraphic, ApiRoomDecorationActive } from './types/api.js'
+export type { RoomHistoryChunk, ApiRoomDecorationsResponse, ApiRoomDecorationItem, ApiRoomDecorationDef, ApiRoomDecorationGraphic, ApiRoomDecorationActive, ApiUserOverviewResponse, ApiUserOverviewTotals, ApiUserRoomsResponse } from './types/api.js'
 export { ROOM_DECORATIONS_MOCK } from './mocks/roomDecorations.js'
 
 export { badgeToSvg } from './badge/index.js'

package/src/stores/MapStatsStore.ts

@@ -11,6 +11,11 @@ export interface MapStatsRoomData {
   safeMode?: boolean
   badge?: ApiMapStatsBadge
   status?: string
+  /**
+   * Controller sign. `user` is the raw signer id; `username`/`badge` are resolved from the
+   * response's user map and may be absent if the signer isn't included there.
+   */
+  sign?: { user: string; text: string; datetime: number; username?: string; badge?: ApiMapStatsBadge }
 }
 
 export interface MapStatsStoreEvents {
@@ -104,6 +109,7 @@ export class MapStatsStore extends TypedStore<MapStatsStoreEvents> {
       }
     }
     const ownerId = stat.own?.user
+    const signUserId = stat.sign?.user
     return {
       own: stat.own,
       mineral,
@@ -112,6 +118,15 @@ export class MapStatsStore extends TypedStore<MapStatsStoreEvents> {
       safeMode: stat.safeMode,
       badge: ownerId ? userMap[ownerId]?.badge : undefined,
       status: stat.status,
+      sign: stat.sign
+        ? {
+            user: stat.sign.user,
+            text: stat.sign.text,
+            datetime: stat.sign.datetime,
+            username: signUserId ? userMap[signUserId]?.username : undefined,
+            badge: signUserId ? userMap[signUserId]?.badge : undefined,
+          }
+        : undefined,
     }
   }
 }

package/src/stores/RoomStore.ts

@@ -8,6 +8,33 @@ import type { SocketClient } from '../socket/SocketClient.js'
 import type { Cache } from '../cache/Cache.js'
 import type { Subscription } from '../subscription/index.js'
 
+function isPlainObject(v: unknown): v is Record<string, unknown> {
+  return typeof v === 'object' && v !== null && !Array.isArray(v)
+}
+
+// Apply a room-object diff onto the previous value following Screeps protocol semantics:
+// the first message for an object carries full state, later ticks send only the fields that
+// changed. Nested objects (`store`, `storeCapacityResource`, `effects`, …) are diffed
+// recursively rather than replaced wholesale — a plain shallow spread would clobber the whole
+// `store` with that tick's single changed resource (e.g. `{ energy }`), silently dropping every
+// other resource until it next changes. A `null` leaf means the field was removed; arrays and
+// primitives replace as-is. Returns fresh objects so previously returned snapshots are never
+// mutated.
+function mergeObjectDiff(prev: Record<string, unknown>, diff: Record<string, unknown>): Record<string, unknown> {
+  const out: Record<string, unknown> = { ...prev }
+  for (const key in diff) {
+    const next = diff[key]
+    if (next === null) {
+      delete out[key]
+    } else if (isPlainObject(next) && isPlainObject(out[key])) {
+      out[key] = mergeObjectDiff(out[key] as Record<string, unknown>, next)
+    } else {
+      out[key] = next
+    }
+  }
+  return out
+}
+
 export class RoomStore extends TypedStore<RoomStoreEvents> {
   private readonly http: HttpClient
   private readonly socket: SocketClient
@@ -190,7 +217,7 @@ export class RoomStore extends TypedStore<RoomStoreEvents> {
           if (obj === null) {
             delete current[id]
           } else if (current[id]) {
-            current[id] = { ...current[id], ...obj } as RoomObject
+            current[id] = mergeObjectDiff(current[id] as Record<string, unknown>, obj as Record<string, unknown>) as RoomObject
           } else {
             current[id] = obj as RoomObject
           }

package/src/types/api.ts

@@ -21,11 +21,38 @@ export interface ApiAuthMeResponse {
   username: string
   cpu: number
   gcl: number
+  /** Raw accumulated power points; Global Power Level derives from this. Absent on servers without the power system. */
+  power?: number
   credits: number
   badge: import('./game.js').Badge
   password: boolean
 }
 
+/** Per-stat lifetime totals over the requested interval — the values behind the Overview stat tiles. Individual fields may be absent on servers that don't track that stat. */
+export interface ApiUserOverviewTotals {
+  energyControl?: number
+  energyHarvested?: number
+  energyConstruction?: number
+  energyCreeps?: number
+  creepsProduced?: number
+  creepsLost?: number
+  powerProcessed?: number
+}
+
+/** Response of GET /api/user/overview. Only `totals` is consumed by the Overview tiles; per-room time series (shards/stats) are omitted until the room band is built. */
+export interface ApiUserOverviewResponse {
+  ok: number
+  totals?: ApiUserOverviewTotals
+  statsMax?: number
+}
+
+/** Response of GET /api/user/rooms?id=<userId> — the rooms a user owns. Multishard servers key by shard; single-shard servers may return a flat list. */
+export interface ApiUserRoomsResponse {
+  ok: number
+  shards?: Record<string, string[]>
+  rooms?: string[]
+}
+
 export interface ApiAuthQueryTokenResponse {
   ok: number
   token: { full: boolean }
@@ -121,6 +148,7 @@ export interface ApiMapStatsRoomStat {
   respawnArea: number | null
   openTime: number | null
   own?: { user: string; level: number }
+  sign?: { user: string; text: string; time: number; datetime: number }
   safeMode?: boolean
   [mineral: `minerals${number}`]: { type: string; density: number } | undefined
 }

package/src/types/events.ts

@@ -68,6 +68,9 @@ export interface HttpClientEvents {
         path: string
         status: number
         error: Error
+        // Set when the request opted out of user-facing error surfacing (e.g. an
+        // optional endpoint whose failure the caller handles gracefully).
+        silent?: boolean
     }
     'http:tokenRefresh': {
         token: string

package/src/types/game.ts

@@ -66,8 +66,12 @@ export interface UserInfo {
     email: string
     cpu: number
     gcl: number
+    /** Raw accumulated power points; Global Power Level derives from this. Absent on servers without the power system. */
+    power?: number
     credits: number
     badge: Badge
+    /** True when the account has a password set. Absent for password-less accounts (e.g. Steam-only logins). Only present for the authenticated user's own info. */
+    password?: boolean
 }
 
 export interface CpuStats {

package/tests/stores/MapStatsStore.test.ts

@@ -231,4 +231,100 @@ describe('MapStatsStore', () => {
     const stat = events[0].stat as { safeMode?: boolean }
     expect(stat.safeMode).toBeUndefined()
   })
+
+  it('passes reservations through as own with level 0', async () => {
+    fetchMock.mockResolvedValue(mockResponse({
+      ok: 1,
+      stats: {
+        W1N1: { own: { user: 'u1', level: 0 } },
+      },
+      users: { u1: { _id: 'u1', username: 'Alice' } },
+    }))
+
+    const events: Array<{ room: string; stat: unknown }> = []
+    store.on('mapStats:room', (e) => events.push(e))
+
+    store.request(['W1N1'], 'owner0')
+
+    await new Promise(r => setTimeout(r, 50))
+    expect(events).toHaveLength(1)
+    const stat = events[0].stat as { own: { user: string; level: number }; username: string }
+    expect(stat.own).toEqual({ user: 'u1', level: 0 })
+    expect(stat.username).toBe('Alice')
+  })
+
+  it('resolves the controller sign with the signer username and badge', async () => {
+    fetchMock.mockResolvedValue(mockResponse({
+      ok: 1,
+      stats: {
+        W1N1: {
+          own: { user: 'u1', level: 5 },
+          sign: { user: 'u1', text: 'Territory of Alice', time: 100, datetime: 1700000000000 },
+        },
+      },
+      users: {
+        u1: { _id: 'u1', username: 'Alice', badge: { type: 7, color1: '#fff', color2: '#000', color3: '#f00', flip: false } },
+      },
+    }))
+
+    const events: Array<{ room: string; stat: unknown }> = []
+    store.on('mapStats:room', (e) => events.push(e))
+
+    store.request(['W1N1'], 'owner0')
+
+    await new Promise(r => setTimeout(r, 50))
+    expect(events).toHaveLength(1)
+    const stat = events[0].stat as { sign: { user: string; text: string; datetime: number; username: string; badge: { type: number } } }
+    expect(stat.sign.user).toBe('u1')
+    expect(stat.sign.text).toBe('Territory of Alice')
+    expect(stat.sign.datetime).toBe(1700000000000)
+    expect(stat.sign.username).toBe('Alice')
+    expect(stat.sign.badge.type).toBe(7)
+  })
+
+  it('keeps the raw signer id but omits username/badge when the signer is not in the user map', async () => {
+    fetchMock.mockResolvedValue(mockResponse({
+      ok: 1,
+      stats: {
+        W1N1: {
+          own: { user: 'u1', level: 4 },
+          sign: { user: 'ghost', text: 'Was here', time: 5, datetime: 1700000000000 },
+        },
+      },
+      users: { u1: { _id: 'u1', username: 'Alice' } },
+    }))
+
+    const events: Array<{ room: string; stat: unknown }> = []
+    store.on('mapStats:room', (e) => events.push(e))
+
+    store.request(['W1N1'], 'owner0')
+
+    await new Promise(r => setTimeout(r, 50))
+    expect(events).toHaveLength(1)
+    const stat = events[0].stat as { sign: { user: string; text: string; username?: string; badge?: unknown } }
+    expect(stat.sign.user).toBe('ghost')
+    expect(stat.sign.text).toBe('Was here')
+    expect(stat.sign.username).toBeUndefined()
+    expect(stat.sign.badge).toBeUndefined()
+  })
+
+  it('omits sign when not present in response', async () => {
+    fetchMock.mockResolvedValue(mockResponse({
+      ok: 1,
+      stats: {
+        W1N1: { own: { user: 'u1', level: 1 } },
+      },
+      users: {},
+    }))
+
+    const events: Array<{ room: string; stat: unknown }> = []
+    store.on('mapStats:room', (e) => events.push(e))
+
+    store.request(['W1N1'], 'owner0')
+
+    await new Promise(r => setTimeout(r, 50))
+    expect(events).toHaveLength(1)
+    const stat = events[0].stat as { sign?: unknown }
+    expect(stat.sign).toBeUndefined()
+  })
 })

package/tests/stores/RoomStore.test.ts

@@ -91,6 +91,103 @@ describe('RoomStore', () => {
     expect(store.objects('W7N7', 'shard0')?.['id1']).toMatchObject({ x: 11, y: 11, type: 'creep' })
   })
 
+  it('deep-merges nested store diffs instead of clobbering the whole store', async () => {
+    const { store, socket } = makeStore()
+    let messageHandler: (data: unknown) => void = () => {}
+    ;(socket.on as ReturnType<typeof vi.fn>).mockImplementation((_ch: string, cb: (data: unknown) => void) => {
+      messageHandler = cb
+      return { dispose: vi.fn() }
+    })
+
+    store.subscribe('W7N7', 'shard0')
+
+    // Full state: a storage holding several resources.
+    messageHandler({
+      objects: { s1: { _id: 's1', type: 'storage', room: 'W7N7', x: 28, y: 26, store: { energy: 239076, power: 2000, H: 5000, L: 5000 } } },
+      gameTime: 1000,
+    })
+
+    // Diff tick: only energy changed within the store.
+    messageHandler({ objects: { s1: { store: { energy: 223706 } } }, gameTime: 1001 })
+
+    // Other resources must survive — a shallow merge would have dropped them.
+    expect((store.objects('W7N7', 'shard0')?.['s1'] as { store: Record<string, number> }).store)
+      .toEqual({ energy: 223706, power: 2000, H: 5000, L: 5000 })
+  })
+
+  it('removes a store resource when the diff sends a null leaf', async () => {
+    const { store, socket } = makeStore()
+    let messageHandler: (data: unknown) => void = () => {}
+    ;(socket.on as ReturnType<typeof vi.fn>).mockImplementation((_ch: string, cb: (data: unknown) => void) => {
+      messageHandler = cb
+      return { dispose: vi.fn() }
+    })
+
+    store.subscribe('W7N7', 'shard0')
+    messageHandler({ objects: { s1: { _id: 's1', type: 'storage', room: 'W7N7', store: { energy: 100, H: 5000 } } }, gameTime: 1000 })
+    messageHandler({ objects: { s1: { store: { H: null } } }, gameTime: 1001 })
+
+    expect((store.objects('W7N7', 'shard0')?.['s1'] as { store: Record<string, number> }).store).toEqual({ energy: 100 })
+  })
+
+  it('replaces array fields wholesale rather than merging them', async () => {
+    const { store, socket } = makeStore()
+    let messageHandler: (data: unknown) => void = () => {}
+    ;(socket.on as ReturnType<typeof vi.fn>).mockImplementation((_ch: string, cb: (data: unknown) => void) => {
+      messageHandler = cb
+      return { dispose: vi.fn() }
+    })
+
+    store.subscribe('W7N7', 'shard0')
+    messageHandler({ objects: { c1: { _id: 'c1', type: 'creep', room: 'W7N7', body: [{ type: 'work' }, { type: 'move' }] } }, gameTime: 1000 })
+    messageHandler({ objects: { c1: { body: [{ type: 'carry' }] } }, gameTime: 1001 })
+
+    expect((store.objects('W7N7', 'shard0')?.['c1'] as { body: unknown[] }).body).toEqual([{ type: 'carry' }])
+  })
+
+  it('does not mutate a previously returned snapshot when applying a diff', async () => {
+    const { store, socket } = makeStore()
+    let messageHandler: (data: unknown) => void = () => {}
+    ;(socket.on as ReturnType<typeof vi.fn>).mockImplementation((_ch: string, cb: (data: unknown) => void) => {
+      messageHandler = cb
+      return { dispose: vi.fn() }
+    })
+
+    store.subscribe('W7N7', 'shard0')
+    messageHandler({ objects: { s1: { _id: 's1', type: 'storage', room: 'W7N7', store: { energy: 100, H: 5000 } } }, gameTime: 1000 })
+    const before = store.objects('W7N7', 'shard0')?.['s1'] as { store: Record<string, number> }
+
+    messageHandler({ objects: { s1: { store: { energy: 200 } } }, gameTime: 1001 })
+
+    // The snapshot captured before the diff must be unchanged.
+    expect(before.store).toEqual({ energy: 100, H: 5000 })
+  })
+
+  // actionLog is a transient per-tick field the client reads from merged state to drive
+  // action beams. The engine emits explicit `null` when an action stops, so deep-merge must
+  // (a) keep an unchanged action across ticks where the diff omits it (continuous beam) and
+  // (b) drop it on a null leaf (beam stops) — never accumulate a stale action.
+  it('keeps a continuing actionLog entry but clears it on an explicit null', async () => {
+    const { store, socket } = makeStore()
+    let messageHandler: (data: unknown) => void = () => {}
+    ;(socket.on as ReturnType<typeof vi.fn>).mockImplementation((_ch: string, cb: (data: unknown) => void) => {
+      messageHandler = cb
+      return { dispose: vi.fn() }
+    })
+
+    store.subscribe('W7N7', 'shard0')
+    // Harvest begins.
+    messageHandler({ objects: { c1: { _id: 'c1', type: 'creep', room: 'W7N7', actionLog: { harvest: { x: 5, y: 6 } } } }, gameTime: 1000 })
+    // Next tick the source is unchanged, so the diff omits actionLog entirely — the beam must persist.
+    messageHandler({ objects: { c1: { fatigue: 0 } }, gameTime: 1001 })
+    expect((store.objects('W7N7', 'shard0')?.['c1'] as { actionLog: Record<string, unknown> }).actionLog)
+      .toEqual({ harvest: { x: 5, y: 6 } })
+    // Creep stops harvesting: the engine sends a null leaf — the entry (and beam) must clear.
+    messageHandler({ objects: { c1: { actionLog: { harvest: null } } }, gameTime: 1002 })
+    expect((store.objects('W7N7', 'shard0')?.['c1'] as { actionLog: Record<string, unknown> }).actionLog)
+      .toEqual({})
+  })
+
   it('emits room:update event on WS message', async () => {
     const { store, socket } = makeStore()
     let messageHandler: (data: unknown) => void = () => {}