screeps-connectivity 0.15.0 → 0.15.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # 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
+
+- 4526471: Namespace the pre-login `/api/authmod` session cache by host **and path**, not hostname alone. Behind `screeps-client-proxy` every backend is wrapped under one host (`localhost/(https://server)`), so hostname-only keys collided and one server's auth capabilities could be shown for another. Also disambiguates private servers that share a hostname on different ports. Matches the path-based namespacing already used for the persistent cache in `ScreepsClient`.
+
 ## 0.15.0
 
 ### Minor Changes

package/package.json

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

package/src/http/fetchServerVersion.ts

@@ -14,7 +14,15 @@ interface CachedEntry<T> {
 
 function sessionKey(suffix: string, url: string): string {
   try {
-    return `screeps:${suffix}:${new URL(url).hostname}`
+    const parsed = new URL(url)
+    // Hostname alone isn't enough: multiple worlds can live under one host via a
+    // path (screeps.com vs screeps.com/season), and behind screeps-client-proxy
+    // every backend is wrapped under the same host (localhost/(https://server)),
+    // so the path must disambiguate them. Same path-based approach as the Cache
+    // namespace in ScreepsClient; host (incl. port) also separates private
+    // servers sharing a hostname on different ports.
+    const path = parsed.pathname.replace(/\/+$/, '')
+    return `screeps:${suffix}:${path ? `${parsed.host}${path}` : parsed.host}`
   } catch {
     return `screeps:${suffix}:${url}`
   }
@@ -60,7 +68,7 @@ export async function fetchServerVersion(url: string): Promise<ServerVersion> {
 /**
  * Fetch screepsmod-auth capabilities from `/api/authmod` without authentication.
  * Returns `null` if the server does not run screepsmod-auth.
- * The result is cached in `sessionStorage` for 5 minutes (per server hostname).
+ * The result is cached in `sessionStorage` for 5 minutes (per server host+path).
  */
 export async function fetchAuthModInfo(url: string): Promise<ApiAuthModInfoResponse | null> {
   const key = sessionKey('authmod', url)

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/http/fetchServerVersion.test.ts

@@ -0,0 +1,52 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { fetchAuthModInfo } from '../../src/http/fetchServerVersion.js'
+
+// Minimal in-memory sessionStorage stub (the node test env has none).
+class MemorySessionStorage {
+  private readonly map = new Map<string, string>()
+  getItem(k: string): string | null { return this.map.get(k) ?? null }
+  setItem(k: string, v: string): void { this.map.set(k, v) }
+  removeItem(k: string): void { this.map.delete(k) }
+  clear(): void { this.map.clear() }
+}
+
+describe('fetchAuthModInfo — session cache namespacing', () => {
+  beforeEach(() => {
+    vi.stubGlobal('sessionStorage', new MemorySessionStorage())
+  })
+  afterEach(() => { vi.unstubAllGlobals() })
+
+  it('does not collide between two backends wrapped under the same proxy host', async () => {
+    // Both URLs share host `localhost:8080`; only the /(backend) path differs —
+    // exactly how screeps-client-proxy addresses distinct servers. The cache key
+    // must include the path, otherwise the second lookup returns the first's data.
+    const worldUrl = 'http://localhost:8080/(https://screeps.com)'
+    const privUrl = 'http://localhost:8080/(http://my-private-server:21025)'
+    // Exact URL → payload map (no substring host matching).
+    const payloads: Record<string, string> = {
+      [`${worldUrl}/api/authmod`]: 'official',
+      [`${privUrl}/api/authmod`]: 'private',
+    }
+    const fetchMock = vi.fn().mockImplementation((input: string) => {
+      return Promise.resolve(
+        new Response(JSON.stringify({ ok: 1, backend: payloads[input] }), {
+          headers: { 'content-type': 'application/json' },
+        }),
+      )
+    })
+    vi.stubGlobal('fetch', fetchMock)
+
+    const world = await fetchAuthModInfo(worldUrl)
+    const priv = await fetchAuthModInfo(privUrl)
+
+    expect((world as { backend?: string })?.backend).toBe('official')
+    expect((priv as { backend?: string })?.backend).toBe('private')
+    // Both were real network fetches — neither served the other's cached entry.
+    expect(fetchMock).toHaveBeenCalledTimes(2)
+
+    // A repeat of the first URL is served from cache (no third fetch).
+    const worldAgain = await fetchAuthModInfo(worldUrl)
+    expect((worldAgain as { backend?: string })?.backend).toBe('official')
+    expect(fetchMock).toHaveBeenCalledTimes(2)
+  })
+})

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)
+  })
 })