screeps-connectivity 0.15.1 → 0.15.2

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.15.2
+
+### Patch Changes
+
+- b39a0c1: Fix duplicated console output when multiple parts of the app subscribe to the same `UserStore` channel. `subscribe()` now installs a single shared, ref-counted socket subscription and listener per channel instead of one listener per caller, so each incoming frame is processed and re-emitted exactly once. The server subscription and listener are torn down only after the last subscriber disposes.
+
 ## 0.15.1
 
 ### Patch Changes

package/package.json

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

package/src/stores/UserStore.ts

@@ -22,6 +22,15 @@ export class UserStore extends TypedStore<UserStoreEvents> {
   private _worldStatus: WorldStatus | null = null
   get worldStatusValue(): WorldStatus | null { return this._worldStatus }
   private _mePromise: Promise<UserInfo> | null = null
+  // Ref-counted store-level fan-out, keyed by channel. SocketClient.subscribe() already ref-counts the
+  // server subscription, but SocketClient.on() installs one listener per call — so a shared listener
+  // must be installed once and reused, otherwise N callers process (and re-emit) every frame N times.
+  private readonly channelSubs = new Map<string, {
+    refCount: number
+    disposed: boolean
+    socketSub: Subscription | null
+    listenerSub: Subscription | null
+  }>()
 
   constructor(http: HttpClient, socket: SocketClient, cache: Cache, logger?: Logger, maxConsoleSize = 100) {
     super(logger)
@@ -84,56 +93,70 @@ export class UserStore extends TypedStore<UserStoreEvents> {
 
   subscribe(channel: 'console' | 'cpu' | 'code' | 'set-active-branch'): 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)
+    // First caller for this channel installs the shared socket subscription + listener; later callers
+    // only bump the ref count so the frame is processed and re-emitted exactly once.
+    let entry = this.channelSubs.get(channel)
+    if (entry) {
+      entry.refCount++
+    } else {
+      entry = { refCount: 1, disposed: false, socketSub: null, listenerSub: null }
+      this.channelSubs.set(channel, entry)
+      const created = entry
+      const setup = async () => {
+        try {
+          const uid = this._userId ?? (await this.me())._id
+          if (created.disposed) return
+          const fullChannel = `user:${uid}/${channel}`
+          created.socketSub = this.socket.subscribe(fullChannel)
+          created.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> })
+            } else if (channel === 'set-active-branch') {
+              this.emit('user:setActiveBranch', data as { activeName: 'activeWorld' | 'activeSim'; branch: string })
             }
-            this.emit('user:console', { messages: msg })
-          } else if (channel === 'code') {
-            this.emit('user:code', data as { branch: string; modules: Record<string, string> })
-          } else if (channel === 'set-active-branch') {
-            this.emit('user:setActiveBranch', data as { activeName: 'activeWorld' | 'activeSim'; branch: string })
+          })
+        } catch (err) {
+          if (!created.disposed) {
+            this.dispatchEvent(new ErrorEvent('error', { error: err instanceof Error ? err : new Error(String(err)) }))
           }
-        })
-      } catch (err) {
-        if (!disposed) {
-          this.dispatchEvent(new ErrorEvent('error', { error: err instanceof Error ? err : new Error(String(err)) }))
         }
       }
+      void setup()
     }
 
-    void setup()
-
+    let disposed = false
     return {
       dispose: () => {
-        this.logger.log('unsubscribe', channel)
+        if (disposed) return
         disposed = true
-        socketSub?.dispose()
-        listenerSub?.dispose()
+        this.logger.log('unsubscribe', channel)
+        const current = this.channelSubs.get(channel)
+        if (!current) return
+        if (--current.refCount <= 0) {
+          current.disposed = true
+          current.socketSub?.dispose()
+          current.listenerSub?.dispose()
+          this.channelSubs.delete(channel)
+        }
       },
     }
   }

package/tests/stores/UserStore.test.ts

@@ -133,4 +133,49 @@ describe('UserStore', () => {
     sub.dispose()
     expect(mockDispose).toHaveBeenCalled()
   })
+
+  it('multiple console subscribers share one socket listener and do not double output', async () => {
+    const { store, socket } = makeStore()
+    await store.me()
+    const handlers: Array<(data: unknown) => void> = []
+    ;(socket.on as ReturnType<typeof vi.fn>).mockImplementation((_ch: string, cb: (data: unknown) => void) => {
+      handlers.push(cb)
+      return { dispose: vi.fn() }
+    })
+    const eventSpy = vi.fn()
+    store.on('user:console', eventSpy)
+
+    // Two independent parts of the app subscribe to the same channel (e.g. the console panel and the
+    // custom-UI store). Regression: this used to install two socket listeners, doubling every frame.
+    store.subscribe('console')
+    store.subscribe('console')
+    await new Promise(r => setTimeout(r, 0))
+
+    // Exactly one socket listener and one server subscription regardless of caller count.
+    expect(handlers).toHaveLength(1)
+    expect(socket.subscribe).toHaveBeenCalledTimes(1)
+
+    // One incoming frame produces exactly one console entry and one event.
+    handlers[0]!({ messages: { log: ['line1'], results: [] } })
+    expect(store.console).toHaveLength(1)
+    expect(eventSpy).toHaveBeenCalledTimes(1)
+  })
+
+  it('console socket subscription is ref-counted and dropped only after the last subscriber', async () => {
+    const { store, socket } = makeStore()
+    await store.me()
+    const mockDispose = vi.fn()
+    ;(socket.subscribe as ReturnType<typeof vi.fn>).mockReturnValue({ dispose: mockDispose })
+
+    const a = store.subscribe('console')
+    const b = store.subscribe('console')
+    await new Promise(r => setTimeout(r, 0))
+    expect(socket.subscribe).toHaveBeenCalledTimes(1)
+
+    a.dispose()
+    expect(mockDispose).not.toHaveBeenCalled() // second subscriber still active
+
+    b.dispose()
+    expect(mockDispose).toHaveBeenCalledTimes(1)
+  })
 })