screeps-connectivity 0.2.4 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## 0.4.0
+
+### Minor Changes
+
+- de4fd47: Add memory watch panel with live WebSocket subscriptions, persistent watchlist, temp creep watch, and inline editing.
+
+  `screeps-connectivity` gains `UserStore.subscribeMemory(path, shard?)` and a new `user:memory` event on `UserStoreEvents`. `screeps-client` adds a full Memory pane to the bottom bar: a persistent watchlist, a temporary per-creep watch triggered from the Eye button on the selection panel, a recursive type-aware `MemoryTree` with expand/collapse, insert-to-console, and inline leaf editing.
+
+## 0.3.0
+
+### Minor Changes
+
+- 9c24c2f: Add memory watch panel with live WebSocket subscriptions, persistent watchlist, temp creep watch, and inline editing.
+
+  `screeps-connectivity` gains `UserStore.subscribeMemory(path, shard?)` and a new `user:memory` event on `UserStoreEvents`. `screeps-client` adds a full Memory pane to the bottom bar: a persistent watchlist, a temporary per-creep watch triggered from the Eye button on the selection panel, a recursive type-aware `MemoryTree` with expand/collapse, insert-to-console, and inline leaf editing.
+
+### Patch Changes
+
+- 31e9570: Fix destroying roads and walls in the property viewer when the user owns the room.
+
+  Roads and walls carry no `user` field, so the destroy button was never shown.
+  The fix falls back to `roomOwner().userId` for ownerless structures and
+  correctly passes `room`, `roomName`, and an optional `shard` in the
+  `destroyStructure` intent — matching the format the official client sends.
+  `addObjectIntent` in `screeps-connectivity` now accepts an optional `shard`
+  parameter.
+
 ## 0.2.4
 
 ### Patch Changes

package/package.json

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

package/src/http/HttpClient.ts

@@ -120,7 +120,8 @@ export class HttpClient extends EventTarget {
       return this.request<T>(method, path, body, true)
     }
 
-    if (!res.ok) {
+    // 304: some servers (e.g. private Screeps) send a body with 304 — treat it as success
+    if (!res.ok && res.status !== 304) {
       let body = ''
       try { body = await res.text() } catch { /* ignore */ }
       const error = new Error(`HTTP ${res.status}: ${body}`)

package/src/http/decompress.ts

@@ -1,31 +1,13 @@
 async function decompress(data: string, format: 'gzip' | 'deflate'): Promise<unknown> {
-  const b64 = data.slice(3) // strip 'gz:' prefix
+  const b64 = data.slice(3) // strip 'gz:' or 'zlib:' prefix
   const binary = Uint8Array.from(atob(b64), c => c.charCodeAt(0))
-  const ds = new DecompressionStream(format)
-  const writer = ds.writable.getWriter()
-  await writer.write(binary)
-  await writer.close()
-  const reader = ds.readable.getReader()
-  const chunks: Uint8Array[] = []
+  const decompressed = new Blob([binary]).stream().pipeThrough(new DecompressionStream(format))
+  const text = await new Response(decompressed).text()
   try {
-    while (true) {
-      const { done, value } = await reader.read()
-      if (done) break
-      chunks.push(value)
-    }
-  } catch (e) {
-    reader.cancel()
-    throw e
+    return JSON.parse(text)
+  } catch {
+    return text
   }
-  let totalLength = 0
-  for (const chunk of chunks) totalLength += chunk.length
-  const result = new Uint8Array(totalLength)
-  let offset = 0
-  for (const chunk of chunks) {
-    result.set(chunk, offset)
-    offset += chunk.length
-  }
-  return JSON.parse(new TextDecoder().decode(result))
 }
 
 export function decompressGzip(data: string): Promise<unknown> {

package/src/http/endpoints/game.ts

@@ -37,7 +37,7 @@ export interface GameEndpoints {
   placeSpawn(room: string, x: number, y: number, name?: string, shard?: string | null): Promise<{ ok: number }>
   createConstruction(room: string, x: number, y: number, structureType: string, name?: string, shard?: string | null): Promise<{ ok: number }>
   removeConstructionSite(room: string, ids: string[], shard?: string | null): Promise<{ ok: number }>
-  addObjectIntent(id: string, room: string, name: string, intent: unknown): Promise<{ ok: number }>
+  addObjectIntent(id: string, room: string, name: string, intent: unknown, shard?: string | null): Promise<{ ok: number }>
   addGlobalIntent(name: string, intent: unknown): Promise<{ ok: number }>
   setNotifyWhenAttacked(id: string, enabled: boolean): Promise<{ ok: number }>
   createInvader(room: string, x: number, y: number, size: number, type: string, boosted?: boolean): Promise<{ ok: number }>
@@ -83,7 +83,7 @@ export function createGameEndpoints(http: HttpClient): GameEndpoints {
     placeSpawn: (room, x, y, name, shard) => http.request('POST', '/api/game/place-spawn', withShard({ room, x, y, ...(name ? { name } : {}) }, shard)),
     createConstruction: (room, x, y, structureType, name, shard) => http.request('POST', '/api/game/create-construction', withShard({ room, x, y, structureType, ...(name ? { name } : {}) }, shard)),
     removeConstructionSite: (room, ids, shard) => http.request('POST', '/api/game/add-object-intent', withShard({ _id: 'room', room, name: 'removeConstructionSite', intent: ids.map(id => ({ id, roomName: room })) }, shard)),
-    addObjectIntent: (id, room, name, intent) => http.request('POST', '/api/game/add-object-intent', { _id: id, room, name, intent }),
+    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 }),
     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 } : {}) }),

package/src/stores/UserStore.ts

@@ -136,6 +136,70 @@ export class UserStore extends TypedStore<UserStoreEvents> {
     }
   }
 
+  subscribeMemory(path: string, shard?: string | null): Subscription {
+    this.logger.log('subscribe memory', path)
+    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 shardSegment = shard ? `${shard}/` : ''
+        const fullChannel = `user:${uid}/memory/${shardSegment}${path}`
+        socketSub = this.socket.subscribe(fullChannel)
+        listenerSub = this.socket.on(fullChannel, (raw) => {
+          if (typeof raw === 'string' && raw.startsWith('gz:')) {
+            void (async () => {
+              try {
+                const { decompressZlib } = await import('../http/decompress.js')
+                const value = await decompressZlib(raw)
+                this.emit('user:memory', { path, shard: shard ?? null, value })
+              } catch (err) {
+                this.logger.log('memory decompress failed', err)
+              }
+            })()
+            return
+          }
+          // Memory values arrive as JSON-encoded strings inside the WS frame,
+          // e.g. the frame ["user:x/memory/foo","1"] delivers raw="1" here.
+          // Objects can't be serialized over WS; the server sends "[object Object]".
+          // Emit a sentinel so the UI can show a collapsed placeholder and fetch
+          // the real value via HTTP only when the user expands it.
+          if (raw === '[object Object]') {
+            this.logger.log('memory object placeholder', path)
+            this.emit('user:memory', { path, shard: shard ?? null, value: { __screeps_object__: true } })
+            return
+          }
+          let value: unknown = raw
+          if (raw === 'undefined') {
+            value = undefined
+          } else if (typeof raw === 'string') {
+            try { value = JSON.parse(raw) } catch { /* leave as-is */ }
+          }
+          this.logger.log('memory value received', path, value)
+          this.emit('user:memory', { path, shard: shard ?? null, value })
+        })
+      } 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 memory', path)
+        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')

package/src/types/events.ts

@@ -41,6 +41,7 @@ export interface UserStoreEvents {
     'user:console': { messages: ConsoleMessage }
     'user:code': { branch: string; modules: Record<string, string> }
     'user:stream': Record<string, unknown>
+    'user:memory': { path: string; shard: string | null; value: unknown }
 }
 
 export interface ServerStoreEvents {