screeps-connectivity 0.2.0

package/tests/cache/Map2Storage.test.ts

@@ -0,0 +1,130 @@
+import { describe, it, expect, beforeEach } from 'vitest'
+import 'fake-indexeddb/auto'
+import { IndexedDBStorage } from '../../src/storage/IndexedDBStorage.js'
+import { Map2Storage } from '../../src/cache/Map2Storage.js'
+import type { RoomMap2Data } from '../../src/types/game.js'
+
+const DATA_A: RoomMap2Data = { s: [[10, 20]], c: [[25, 25]] }
+const DATA_B: RoomMap2Data = { m: [[30, 30]] }
+
+function makeStorage(maxEntries = 100) {
+  const adapter = new IndexedDBStorage(`map2-test-${Math.random()}`)
+  const storage = new Map2Storage({ adapter, namespace: 'test.local', maxEntries })
+  return storage
+}
+
+describe('Map2Storage — memory path', () => {
+  it('getMemory() returns null when entry not yet loaded', () => {
+    const storage = makeStorage()
+    expect(storage.getMemory('W7N7', 'shard0')).toBeNull()
+  })
+
+  it('get() returns null when adapter has no entry', async () => {
+    const storage = makeStorage()
+    expect(await storage.get('W7N7', 'shard0')).toBeNull()
+  })
+
+  it('put() makes data immediately available via getMemory()', async () => {
+    const storage = makeStorage()
+    void storage.put('W7N7', 'shard0', DATA_A)  // don't await — memory is sync
+    expect(storage.getMemory('W7N7', 'shard0')).toEqual(DATA_A)
+  })
+})
+
+describe('Map2Storage — IndexedDB persistence', () => {
+  it('put() persists data; get() retrieves it after memory is cold', async () => {
+    const adapter = new IndexedDBStorage(`map2-test-${Math.random()}`)
+    const storage1 = new Map2Storage({ adapter, namespace: 'test.local', maxEntries: 100 })
+    await storage1.put('W7N7', 'shard0', DATA_A)
+
+    // Simulate cold start: fresh storage instance sharing the same adapter
+    const storage2 = new Map2Storage({ adapter, namespace: 'test.local', maxEntries: 100 })
+    const result = await storage2.get('W7N7', 'shard0')
+    expect(result).toEqual(DATA_A)
+  })
+
+  it('get() hydrates memory from IndexedDB on hit', async () => {
+    const adapter = new IndexedDBStorage(`map2-test-${Math.random()}`)
+    const storage1 = new Map2Storage({ adapter, namespace: 'test.local', maxEntries: 100 })
+    await storage1.put('W7N7', 'shard0', DATA_A)
+
+    const storage2 = new Map2Storage({ adapter, namespace: 'test.local', maxEntries: 100 })
+    await storage2.get('W7N7', 'shard0')
+    // After hydration, getMemory() must return the data synchronously
+    expect(storage2.getMemory('W7N7', 'shard0')).toEqual(DATA_A)
+  })
+
+  it('put() with null shard stores under _ namespace', async () => {
+    const adapter = new IndexedDBStorage(`map2-test-${Math.random()}`)
+    const storage1 = new Map2Storage({ adapter, namespace: 'test.local', maxEntries: 100 })
+    await storage1.put('E9N3', null, DATA_B)
+
+    const storage2 = new Map2Storage({ adapter, namespace: 'test.local', maxEntries: 100 })
+    expect(await storage2.get('E9N3', null)).toEqual(DATA_B)
+    expect(await storage2.get('E9N3', 'shard0')).toBeNull()
+  })
+
+  it('different Map2Storage instances with different adapters do not share data', async () => {
+    const adapter1 = new IndexedDBStorage(`map2-test-${Math.random()}`)
+    const adapter2 = new IndexedDBStorage(`map2-test-${Math.random()}`)
+    const s1 = new Map2Storage({ adapter: adapter1, namespace: 'a', maxEntries: 100 })
+    const s2 = new Map2Storage({ adapter: adapter2, namespace: 'b', maxEntries: 100 })
+
+    await s1.put('W7N7', 'shard0', DATA_A)
+    expect(await s2.get('W7N7', 'shard0')).toBeNull()
+  })
+})
+
+describe('Map2Storage — LRU eviction with IndexedDB', () => {
+  it('evicts LRU entry from both memory and IndexedDB when over maxEntries', async () => {
+    const adapter = new IndexedDBStorage(`map2-test-${Math.random()}`)
+    const storage = new Map2Storage({ adapter, namespace: 'test.local', maxEntries: 2 })
+
+    await storage.put('W1N1', null, DATA_A)
+    await storage.put('W2N2', null, DATA_A)
+    storage.getMemory('W1N1', null)           // touch W1N1 → W2N2 becomes oldest
+    await storage.put('W3N3', null, DATA_A)   // triggers eviction of W2N2
+
+    // Memory check
+    expect(storage.getMemory('W1N1', null)).not.toBeNull()
+    expect(storage.getMemory('W2N2', null)).toBeNull()
+    expect(storage.getMemory('W3N3', null)).not.toBeNull()
+
+    // IndexedDB check via a cold storage instance
+    const cold = new Map2Storage({ adapter, namespace: 'test.local', maxEntries: 100 })
+    expect(await cold.get('W1N1', null)).toEqual(DATA_A)
+    expect(await cold.get('W2N2', null)).toBeNull()
+    expect(await cold.get('W3N3', null)).toEqual(DATA_A)
+  })
+
+  it('memory-only eviction still works when adapter is null', async () => {
+    const storage = new Map2Storage({ adapter: null, namespace: 'test.local', maxEntries: 2 })
+    const data: RoomMap2Data = {}
+
+    void storage.put('W1N1', null, data)
+    void storage.put('W2N2', null, data)
+    storage.getMemory('W1N1', null)   // touch W1N1
+    void storage.put('W3N3', null, data)
+
+    expect(storage.getMemory('W1N1', null)).not.toBeNull()
+    expect(storage.getMemory('W2N2', null)).toBeNull()
+    expect(storage.getMemory('W3N3', null)).not.toBeNull()
+  })
+})
+
+describe('Map2Storage — null adapter', () => {
+  let storage: Map2Storage
+
+  beforeEach(() => {
+    storage = new Map2Storage({ adapter: null, namespace: 'offline', maxEntries: 10 })
+  })
+
+  it('get() returns null when adapter is null and memory is empty', async () => {
+    expect(await storage.get('W7N7', 'shard0')).toBeNull()
+  })
+
+  it('put() + get() works via memory only when adapter is null', async () => {
+    await storage.put('W7N7', 'shard0', DATA_A)
+    expect(await storage.get('W7N7', 'shard0')).toEqual(DATA_A)
+  })
+})

package/tests/http/HttpClient.test.ts

@@ -0,0 +1,188 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { HttpClient } from '../../src/http/HttpClient.js'
+import { TokenAuth } from '../../src/http/auth/TokenAuth.js'
+
+function mockResponse(body: unknown, opts: ResponseInit = {}): Response {
+  return new Response(JSON.stringify(body), {
+    status: 200,
+    headers: { 'content-type': 'application/json', ...opts.headers },
+    ...opts,
+  })
+}
+
+describe('HttpClient', () => {
+  let fetchMock: ReturnType<typeof vi.fn>
+
+  beforeEach(() => {
+    fetchMock = vi.fn()
+    vi.stubGlobal('fetch', fetchMock)
+  })
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  it('attaches X-Token and X-Username headers after authenticate()', async () => {
+    fetchMock.mockResolvedValue(mockResponse({ ok: 1 }))
+    const http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 'tok123' }) })
+    await http.authenticate()
+    await http.request('GET', '/api/version')
+    const [, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    const headers = init.headers as Record<string, string>
+    expect(headers['X-Token']).toBe('tok123')
+    // passport-token requires both x-token and x-username; server ignores the username value
+    expect(headers['X-Username']).toBe('tok123')
+  })
+
+  it('attaches X-Server-Password header when serverPassword is set', async () => {
+    fetchMock.mockResolvedValue(mockResponse({ ok: 1 }))
+    const http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 't' }), serverPassword: 'secret' })
+    await http.request('GET', '/api/version')
+    const [, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    const headers = init.headers as Record<string, string>
+    expect(headers['X-Server-Password']).toBe('secret')
+  })
+
+  it('omits X-Server-Password header when serverPassword is not set', async () => {
+    fetchMock.mockResolvedValue(mockResponse({ ok: 1 }))
+    const http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 't' }) })
+    await http.request('GET', '/api/version')
+    const [, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    const headers = init.headers as Record<string, string>
+    expect(headers['X-Server-Password']).toBeUndefined()
+  })
+
+  it('sends GET params as query string', async () => {
+    fetchMock.mockResolvedValue(mockResponse({ ok: 1 }))
+    const http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 't' }) })
+    await http.request('GET', '/api/game/time', { shard: 'shard0' })
+    const [url] = fetchMock.mock.calls[0] as [string]
+    expect(url).toContain('shard=shard0')
+  })
+
+  it('omits null GET params from query string', async () => {
+    fetchMock.mockResolvedValue(mockResponse({ ok: 1 }))
+    const http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 't' }) })
+    await http.request('GET', '/api/game/time', { shard: null, room: 'E9N3' })
+    const [url] = fetchMock.mock.calls[0] as [string]
+    expect(url).not.toContain('shard')
+    expect(url).toContain('room=E9N3')
+  })
+
+  it('sends POST body as JSON', async () => {
+    fetchMock.mockResolvedValue(mockResponse({ ok: 1 }))
+    const http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 't' }) })
+    await http.request('POST', '/api/user/console', { expression: 'Game.time', shard: 'shard0' })
+    const [, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(JSON.parse(init.body as string)).toEqual({ expression: 'Game.time', shard: 'shard0' })
+  })
+
+  it('updates token from x-token response header', async () => {
+    fetchMock.mockResolvedValue(mockResponse({ ok: 1 }, {
+      headers: { 'content-type': 'application/json', 'x-token': 'refreshed' },
+    }))
+    const http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 'old' }) })
+    http.token = 'old'
+    await http.request('GET', '/api/version')
+    expect(http.token).toBe('refreshed')
+  })
+
+  it('retries once on 401 after re-authenticating', async () => {
+    let calls = 0
+    fetchMock.mockImplementation(() => {
+      calls++
+      if (calls === 1) return Promise.resolve(new Response('Unauthorized', { status: 401 }))
+      return Promise.resolve(mockResponse({ ok: 1 }))
+    })
+    const http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 'tok' }) })
+    http.token = 'tok'
+    await http.request('GET', '/api/version')
+    expect(calls).toBe(2)
+  })
+
+  it('throws immediately on 401 during authenticate() — no recursion', async () => {
+    fetchMock.mockResolvedValue(new Response('Unauthorized', { status: 401 }))
+    const badAuth = {
+      authenticate: (http: HttpClient) => http.request<{ token: string }>('POST', '/api/auth/signin', { email: 'x', password: 'wrong' }).then(r => r.token),
+    }
+    const http = new HttpClient({ url: 'http://test.local', auth: badAuth })
+    await expect(http.authenticate()).rejects.toThrow('HTTP 401')
+    // fetchMock called exactly once — no retry loop
+    expect(fetchMock).toHaveBeenCalledOnce()
+  })
+
+  it('does not retry a second time if re-auth 401 persists', async () => {
+    fetchMock.mockResolvedValue(new Response('Unauthorized', { status: 401 }))
+    const http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 'tok' }) })
+    http.token = 'tok'
+    await expect(http.request('GET', '/api/version')).rejects.toThrow('HTTP 401')
+  })
+
+  it('throws on non-401 error status', async () => {
+    fetchMock.mockResolvedValue(new Response('Server Error', { status: 500 }))
+    const http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 't' }) })
+    await expect(http.request('GET', '/api/version')).rejects.toThrow('HTTP 500')
+  })
+
+  it('decompresses gz: data field', async () => {
+    // Non-gz response data passes through unchanged
+    fetchMock.mockResolvedValue(mockResponse({ ok: 1, data: { result: 42 } }))
+    const http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 't' }) })
+    const res = await http.request<{ ok: number; data: { result: number } }>('GET', '/api/test')
+    expect(res.data.result).toBe(42)
+  })
+
+  it('emits http:tokenRefresh when x-token header is present', async () => {
+    fetchMock.mockResolvedValue(mockResponse({ ok: 1 }, {
+      headers: { 'content-type': 'application/json', 'x-token': 'new-tok' },
+    }))
+    const http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 'old' }) })
+    const handler = vi.fn()
+    http.on('http:tokenRefresh', handler)
+    await http.request('GET', '/api/version')
+    expect(handler).toHaveBeenCalledWith({ token: 'new-tok' })
+  })
+
+  it('emits http:success on 200 response', async () => {
+    fetchMock.mockResolvedValue(mockResponse({ ok: 1 }))
+    const http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 't' }) })
+    const handler = vi.fn()
+    http.on('http:success', handler)
+    await http.request('GET', '/api/version')
+    expect(handler).toHaveBeenCalledWith({ method: 'GET', path: '/api/version', status: 200 })
+  })
+
+  it('emits http:error on non-2xx response', async () => {
+    fetchMock.mockResolvedValue(new Response('Server Error', { status: 500 }))
+    const http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 't' }) })
+    const handler = vi.fn()
+    http.on('http:error', handler)
+    await expect(http.request('GET', '/api/version')).rejects.toThrow('HTTP 500')
+    expect(handler).toHaveBeenCalledOnce()
+    const arg = handler.mock.calls[0][0]
+    expect(arg.method).toBe('GET')
+    expect(arg.path).toBe('/api/version')
+    expect(arg.status).toBe(500)
+    expect(arg.error).toBeInstanceOf(Error)
+  })
+
+  it('throws on 200 with error in response body', async () => {
+    fetchMock.mockResolvedValue(mockResponse({ ok: 0, error: 'invalid params' }))
+    const http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 't' }) })
+    await expect(http.request('GET', '/api/game/create-flag')).rejects.toThrow('Screeps API error: invalid params')
+  })
+
+  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' }) })
+    const handler = vi.fn()
+    http.on('http:error', handler)
+    await expect(http.request('POST', '/api/game/create-flag')).rejects.toThrow('Screeps API error: flags limit exceeded')
+    expect(handler).toHaveBeenCalledOnce()
+    const arg = handler.mock.calls[0][0]
+    expect(arg.method).toBe('POST')
+    expect(arg.path).toBe('/api/game/create-flag')
+    expect(arg.status).toBe(200)
+    expect(arg.error).toBeInstanceOf(Error)
+  })
+})

package/tests/http/decompress.test.ts

@@ -0,0 +1,52 @@
+import { describe, it, expect } from 'vitest'
+import { createGzip, createDeflate } from 'node:zlib'
+import { promisify } from 'node:util'
+import { pipeline } from 'node:stream'
+import { Readable } from 'node:stream'
+import { decompressGzip, decompressZlib } from '../../src/http/decompress.js'
+
+const pipelineAsync = promisify(pipeline)
+
+async function gzipEncode(json: unknown): Promise<string> {
+  const input = Buffer.from(JSON.stringify(json))
+  const chunks: Buffer[] = []
+  const gz = createGzip()
+  await pipelineAsync(Readable.from(input), gz, async function*(source) {
+    for await (const chunk of source) {
+      chunks.push(chunk as Buffer)
+      yield chunk
+    }
+  })
+  return 'gz:' + Buffer.concat(chunks).toString('base64')
+}
+
+async function zlibEncode(json: unknown): Promise<string> {
+  const input = Buffer.from(JSON.stringify(json))
+  const chunks: Buffer[] = []
+  const def = createDeflate()
+  await pipelineAsync(Readable.from(input), def, async function*(source) {
+    for await (const chunk of source) {
+      chunks.push(chunk as Buffer)
+      yield chunk
+    }
+  })
+  return 'gz:' + Buffer.concat(chunks).toString('base64')
+}
+
+describe('decompressGzip', () => {
+  it('decompresses a gzip-encoded gz: string', async () => {
+    const payload = { message: 'hello', value: 42 }
+    const encoded = await gzipEncode(payload)
+    const result = await decompressGzip(encoded)
+    expect(result).toEqual(payload)
+  })
+})
+
+describe('decompressZlib', () => {
+  it('decompresses a zlib-encoded gz: string', async () => {
+    const payload = [{ channel: 'user:x/cpu', data: { cpu: 10 } }]
+    const encoded = await zlibEncode(payload)
+    const result = await decompressZlib(encoded)
+    expect(result).toEqual(payload)
+  })
+})

package/tests/http/endpoints/auth.test.ts

@@ -0,0 +1,126 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { HttpClient } from '../../../src/http/HttpClient.js'
+import { TokenAuth } from '../../../src/http/auth/TokenAuth.js'
+import { SteamTicketAuth } from '../../../src/http/auth/SteamTicketAuth.js'
+
+function mockResponse(body: unknown, opts: ResponseInit = {}): Response {
+  return new Response(JSON.stringify(body), {
+    status: 200,
+    headers: { 'content-type': 'application/json', ...opts.headers },
+    ...opts,
+  })
+}
+
+describe('auth endpoints', () => {
+  let fetchMock: ReturnType<typeof vi.fn>
+  let http: HttpClient
+
+  beforeEach(() => {
+    fetchMock = vi.fn().mockResolvedValue(mockResponse({ ok: 1 }))
+    vi.stubGlobal('fetch', fetchMock)
+    http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 't' }) })
+  })
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  it('steamTicket sends POST with ticket', async () => {
+    fetchMock.mockResolvedValue(mockResponse({ ok: 1, token: 'tok', steamid: 'steam123' }))
+    const res = await http.auth.steamTicket('ticket-value')
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('POST')
+    expect(url).toContain('/api/auth/steam-ticket')
+    expect(JSON.parse(init.body as string)).toEqual({ ticket: 'ticket-value' })
+    expect(res.token).toBe('tok')
+    expect(res.steamid).toBe('steam123')
+  })
+
+  it('steamTicket includes useNativeAuth when provided', async () => {
+    fetchMock.mockResolvedValue(mockResponse({ ok: 1, token: 'tok', steamid: 'steam123' }))
+    await http.auth.steamTicket('ticket-value', true)
+    const body = JSON.parse(fetchMock.mock.calls[0][1].body as string)
+    expect(body).toEqual({ ticket: 'ticket-value', useNativeAuth: true })
+  })
+})
+
+describe('SteamTicketAuth strategy', () => {
+  let fetchMock: ReturnType<typeof vi.fn>
+
+  beforeEach(() => {
+    fetchMock = vi.fn()
+    vi.stubGlobal('fetch', fetchMock)
+  })
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  it('authenticate() calls steam-ticket and returns the token', async () => {
+    fetchMock.mockResolvedValue(new Response(JSON.stringify({ ok: 1, token: 'steam-tok', steamid: 'sid' }), {
+      status: 200, headers: { 'content-type': 'application/json' },
+    }))
+    const http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: '' }) })
+    const strategy = new SteamTicketAuth({ ticket: 'my-steam-ticket' })
+    const token = await strategy.authenticate(http)
+    expect(token).toBe('steam-tok')
+    const body = JSON.parse(fetchMock.mock.calls[0][1].body as string)
+    expect(body).toEqual({ ticket: 'my-steam-ticket' })
+  })
+
+  it('passes useNativeAuth when set', async () => {
+    fetchMock.mockResolvedValue(new Response(JSON.stringify({ ok: 1, token: 't', steamid: 's' }), {
+      status: 200, headers: { 'content-type': 'application/json' },
+    }))
+    const http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: '' }) })
+    const strategy = new SteamTicketAuth({ ticket: 'ticket', useNativeAuth: true })
+    await strategy.authenticate(http)
+    const body = JSON.parse(fetchMock.mock.calls[0][1].body as string)
+    expect(body.useNativeAuth).toBe(true)
+  })
+})
+
+describe('register endpoints', () => {
+  let fetchMock: ReturnType<typeof vi.fn>
+  let http: HttpClient
+
+  beforeEach(() => {
+    fetchMock = vi.fn().mockResolvedValue(mockResponse({ ok: 1 }))
+    vi.stubGlobal('fetch', fetchMock)
+    http = new HttpClient({ url: 'http://test.local', auth: new TokenAuth({ token: 't' }) })
+  })
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  it('checkEmail sends GET with email query param', async () => {
+    await http.register.checkEmail('test@example.com')
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('GET')
+    expect(url).toContain('/api/register/check-email')
+    expect(url).toContain('email=test%40example.com')
+  })
+
+  it('checkUsername sends GET with username query param', async () => {
+    await http.register.checkUsername('Tigga')
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('GET')
+    expect(url).toContain('/api/register/check-username')
+    expect(url).toContain('username=Tigga')
+  })
+
+  it('setUsername sends POST with username', async () => {
+    await http.register.setUsername('Tigga')
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(init.method).toBe('POST')
+    expect(url).toContain('/api/register/set-username')
+    expect(JSON.parse(init.body as string)).toEqual({ username: 'Tigga' })
+  })
+
+  it('setUsername includes email when provided', async () => {
+    await http.register.setUsername('Tigga', 'tigga@example.com')
+    const body = JSON.parse(fetchMock.mock.calls[0][1].body as string)
+    expect(body).toEqual({ username: 'Tigga', email: 'tigga@example.com' })
+  })
+})