screeps-connectivity 0.13.0 → 0.13.1

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.13.1
+
+### Patch Changes
+
+- 661a53f: Don't show the "Connection lost" modal after an intentional disconnect. A guest hitting Login (or any user logging out) tore the session down synchronously, but the socket's async `onclose` still fired `server:disconnected` with `willReconnect: false`, which re-raised a fatal session error over the login screen. The disconnected event now carries an `intentional` flag so the client can distinguish a user-initiated close from a genuinely lost connection.
+- 9bc39f8: History viewer fixes and a couple of supporting connectivity additions:
+
+  - Render terrain when reloading directly into history mode. Terrain loading was gated behind the room-subscription effect, which is skipped in history mode, so a fresh reload into a `#tick=` URL showed no terrain. Terrain/decoration loading now runs independently of history mode.
+  - Open the history view at the start of the previous, fully-written chunk instead of the current tick (whose chunk isn't flushed yet), avoiding an immediate 404 + fallback round-trip.
+  - Suppress the red failure toast when a history chunk is missing (404). `roomHistory` requests are now `silent`, and the viewer shows an in-room "No data available for this tick" hint instead, prompting the user to pick another tick from the timeline.
+  - During playback, skip to the start of the next chunk when the current chunk is missing, instead of re-fetching the same non-existent file on every tick.
+  - Expose `serverData.historyKeepTicks` (non-official field from the xxscreeps history mod) on the version types, used to size the history timeline's replayable range (falls back to a default window when absent).
+  - HTTP errors thrown by `HttpClient` now carry a `status` property so callers can distinguish a 404 from other failures.
+  - Dev-only: proxy `/room-history` to `VITE_PROXY_TARGET` in the Vite dev server.
+
+- 1e85697: Accept the xxscreeps `{ error: "actually, it was fine" }` sentinel (returned with status 200 by the `create-construction` route to signal success) as a successful response instead of throwing.
+
 ## 0.13.0
 
 ### Minor Changes

package/package.json

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

package/src/http/HttpClient.ts

@@ -11,6 +11,12 @@ import { createRegisterEndpoints, type RegisterEndpoints } from './endpoints/reg
 import type { HttpClientEvents } from '../types/events.js'
 import type { Subscription } from '../subscription/index.js'
 
+/** xxscreeps' /api/game/create-construction route returns this in an { error }
+ *  field with status 200 to signal success. Official Screeps inserts the site
+ *  directly and returns an id, but xxscreeps returns this fake error and relies
+ *  on the room socket to show the site next tick. It is not a real error. */
+const XXSCREEPS_FALSE_ERROR = 'actually, it was fine'
+
 export interface RateLimitInfo {
   limit: number
   remaining: number
@@ -133,7 +139,8 @@ export class HttpClient extends EventTarget {
     if (!res.ok && res.status !== 304) {
       let body = ''
       try { body = await res.text() } catch { /* ignore */ }
-      const error = new Error(`HTTP ${res.status}: ${body}`)
+      const error = new Error(`HTTP ${res.status}: ${body}`) as Error & { status?: number }
+      error.status = res.status
       this.emit('http:error', { method, path, status: res.status, error, silent: opts.silent })
       throw error
     }
@@ -142,6 +149,13 @@ export class HttpClient extends EventTarget {
 
     const data = await res.json() as Record<string, unknown>
 
+    // xxscreeps' create-construction route returns { error: 'actually, it was
+    // fine' } with status 200 to signal success (see XXSCREEPS_FALSE_ERROR).
+    // Treat this sentinel as success, not an error.
+    if (data['error'] === XXSCREEPS_FALSE_ERROR) {
+      delete data['error']
+    }
+
     if (typeof data['error'] === 'string') {
       const error = new Error(`Screeps API error: ${data['error']}`)
       this.emit('http:error', { method, path, status: res.status, error, silent: opts.silent })

package/src/http/endpoints/game.ts

@@ -98,9 +98,11 @@ export function createGameEndpoints(http: HttpClient, decorationsMock?: ApiRoomD
     addObjectIntent: (id, room, name, intent, shard) => http.request('POST', '/api/game/add-object-intent', withShard({ _id: id, room, name, intent }, shard)),
     addGlobalIntent: (name, intent) => http.request('POST', '/api/game/add-global-intent', { name, intent }),
     roomHistory: (room, time, shard) =>
+      // silent: a missing chunk 404s while history is still being written; the caller
+      // handles that gracefully, so don't surface a global "request failed" toast.
       shard
-        ? http.request('GET', `/room-history/${encodeURIComponent(shard)}/${encodeURIComponent(room)}/${time}.json`)
-        : http.request('GET', '/room-history', { room, time }),
+        ? http.request('GET', `/room-history/${encodeURIComponent(shard)}/${encodeURIComponent(room)}/${time}.json`, undefined, { silent: true })
+        : http.request('GET', '/room-history', { room, time }, { silent: true }),
     setNotifyWhenAttacked: (id, enabled) => http.request('POST', '/api/game/set-notify-when-attacked', { _id: id, enabled }),
     createInvader: (room, x, y, size, type, boosted) => http.request('POST', '/api/game/create-invader', { room, x, y, size, type, ...(boosted != null ? { boosted } : {}) }),
     removeInvader: (id) => http.request('POST', '/api/game/remove-invader', { _id: id }),

package/src/socket/SocketClient.ts

@@ -79,7 +79,7 @@ export class SocketClient {
         this.authed = false
         this.authSub?.dispose()
         this.authSub = null
-        this.emit('disconnected', { willReconnect: this.reconnecting })
+        this.emit('disconnected', { willReconnect: this.reconnecting, intentional: this._intentionalClose })
         void this.scheduleReconnect()
       }
       this.ws.onerror = (err) => {

package/src/stores/ServerStore.ts

@@ -29,8 +29,8 @@ export class ServerStore extends TypedStore<ServerStoreEvents> {
       this.emit('server:connected', {})
     }))
     this.socketSubs.push(socket.on('disconnected', (data) => {
-      const d = data as { willReconnect: boolean }
-      this.emit('server:disconnected', { willReconnect: d.willReconnect })
+      const d = data as { willReconnect: boolean; intentional?: boolean }
+      this.emit('server:disconnected', { willReconnect: d.willReconnect, intentional: d.intentional ?? false })
     }))
     this.socketSubs.push(socket.on('socket:error', (data) => {
       this.emit('server:error', { error: data instanceof Error ? data : new Error(String(data)) })

package/src/types/api.ts

@@ -102,6 +102,13 @@ export interface ApiVersionResponse {
   users: number
   serverData: {
     historyChunkSize: number
+    /**
+     * Retention window for room history, in ticks. Non-official field added by the
+     * xxscreeps history mod. When present, the earliest replayable tick is roughly
+     * `currentTick - historyKeepTicks`; a value of `0` means history is kept forever
+     * (unbounded). Absent on servers without the mod.
+     */
+    historyKeepTicks?: number
     features: Array<{ name: string }>
     shards: string[]
     customObjectTypes?: unknown

package/src/types/events.ts

@@ -47,7 +47,7 @@ export interface UserStoreEvents {
 
 export interface ServerStoreEvents {
     'server:connected': Record<string, never>
-    'server:disconnected': { willReconnect: boolean }
+    'server:disconnected': { willReconnect: boolean; intentional: boolean }
     'server:error': { error: Error }
     'server:version': ServerVersion
     'server:shards': ShardInfo[]

package/src/types/game.ts

@@ -145,6 +145,14 @@ export interface ServerVersion {
     users: number
     serverData: {
         historyChunkSize: number
+        /**
+         * Retention window for room history, in ticks. Non-official field added by the
+         * xxscreeps history mod. When present, the earliest replayable tick is roughly
+         * `currentTick - historyKeepTicks`; a value of `0` means history is kept forever
+         * (unbounded). Absent on servers without the mod — callers should fall back to a
+         * sensible default in that case.
+         */
+        historyKeepTicks?: number
         features: ServerFeature[]
         shards: Array<string | null>
         welcomeText?: string

package/tests/http/HttpClient.test.ts

@@ -205,6 +205,16 @@ describe('HttpClient', () => {
     await expect(http.request('GET', '/api/game/create-flag')).rejects.toThrow('Screeps API error: invalid params')
   })
 
+  it('treats the xxscreeps "actually, it was fine" sentinel as success', async () => {
+    fetchMock.mockResolvedValue(mockResponse({ error: 'actually, it was fine' }))
+    const http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 't' }) })
+    const errorHandler = vi.fn()
+    http.on('http:error', errorHandler)
+    const res = await http.request<{ error?: string }>('POST', '/api/game/create-construction')
+    expect(res.error).toBeUndefined()
+    expect(errorHandler).not.toHaveBeenCalled()
+  })
+
   it('emits http:error on 200 with error in response body', async () => {
     fetchMock.mockResolvedValue(mockResponse({ ok: 0, error: 'flags limit exceeded' }))
     const http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 't' }) })

package/tests/socket/SocketClient.test.ts

@@ -141,4 +141,15 @@ describe('SocketClient', () => {
     client.disconnect()
     expect(willReconnect).toBe(false)
   })
+
+  it('disconnected event is flagged intentional when disconnect() is called', async () => {
+    const client = makeClient()
+    const _ws = await connectClient(client)
+    let intentional: boolean | undefined
+    client.on('disconnected', (data) => {
+      intentional = (data as { intentional: boolean }).intentional
+    })
+    client.disconnect()
+    expect(intentional).toBe(true)
+  })
 })