@swarmclawai/swarmclaw 0.7.7 → 0.8.0

package/src/lib/server/clawhub-client.test.ts

@@ -25,21 +25,26 @@ describe('searchClawHub', () => {
   // We'll test the default URL by importing once.
 
   it('constructs correct URL with query params and returns parsed JSON', async () => {
-    const mockData = { skills: [{ id: 's1', name: 'test-skill' }], total: 1, page: 1 }
+    const mockRaw = { items: [{ slug: 's1', displayName: 'test-skill' }], total: 1 }
     let capturedUrl = ''
 
     globalThis.fetch = async (input: RequestInfo | URL) => {
       capturedUrl = String(input)
-      return new Response(JSON.stringify(mockData), { status: 200 })
+      return new Response(JSON.stringify(mockRaw), { status: 200 })
     }
 
     const { searchClawHub } = await import('./clawhub-client.ts')
     const result = await searchClawHub('hello world', 2, 10)
 
-    assert.ok(capturedUrl.includes('/skills?q=hello%20world&page=2&limit=10'))
-    assert.deepStrictEqual(result.skills, mockData.skills)
+    assert.ok(capturedUrl.includes('/skills?'), `expected skills query in URL: ${capturedUrl}`)
+    assert.ok(capturedUrl.includes('q=hello'), `expected q param: ${capturedUrl}`)
+    assert.ok(capturedUrl.includes('limit=10'), `expected limit=10: ${capturedUrl}`)
+    assert.ok(capturedUrl.includes('page=2'), `expected page=2: ${capturedUrl}`)
+    assert.equal(result.skills.length, 1)
+    assert.equal(result.skills[0].id, 's1')
+    assert.equal(result.skills[0].name, 'test-skill')
     assert.equal(result.total, 1)
-    assert.equal(result.page, 1)
+    assert.equal(result.page, 2)
   })
 
   it('uses default page=1 and limit=20', async () => {
@@ -53,8 +58,9 @@ describe('searchClawHub', () => {
     const { searchClawHub } = await import('./clawhub-client.ts')
     await searchClawHub('test')
 
-    assert.ok(capturedUrl.includes('page=1'))
-    assert.ok(capturedUrl.includes('limit=20'))
+    // page=1 is omitted from the URL since the server defaults to page 1
+    assert.ok(!capturedUrl.includes('page='), `page param should be omitted for default: ${capturedUrl}`)
+    assert.ok(capturedUrl.includes('limit=20'), `expected limit=20: ${capturedUrl}`)
   })
 
   it('uses default base URL when CLAWHUB_API_URL is not set', async () => {
@@ -68,7 +74,7 @@ describe('searchClawHub', () => {
     const { searchClawHub } = await import('./clawhub-client.ts')
     await searchClawHub('q')
 
-    assert.ok(capturedUrl.startsWith('https://clawhub.openclaw.dev/api/skills'))
+    assert.ok(capturedUrl.startsWith('https://clawhub.ai/api/v1/skills'), `expected clawhub.ai base URL: ${capturedUrl}`)
   })
 
   it('returns empty results on non-200 response', async () => {

package/src/lib/server/connectors/manager-reconnect.test.ts

@@ -0,0 +1,47 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import {
+  advanceConnectorReconnectState,
+  createConnectorReconnectState,
+} from './manager'
+
+test('advanceConnectorReconnectState applies exponential backoff and exhaustion', () => {
+  const policy = {
+    initialBackoffMs: 30_000,
+    maxBackoffMs: 15 * 60 * 1000,
+    maxAttempts: 3,
+  }
+
+  const initial = createConnectorReconnectState({}, policy)
+
+  const first = advanceConnectorReconnectState(initial, 'boom-1', 1_000, policy)
+  assert.equal(first.attempts, 1)
+  assert.equal(first.backoffMs, 30_000)
+  assert.equal(first.nextRetryAt, 31_000)
+  assert.equal(first.exhausted, false)
+
+  const second = advanceConnectorReconnectState(first, 'boom-2', 31_000, policy)
+  assert.equal(second.attempts, 2)
+  assert.equal(second.backoffMs, 60_000)
+  assert.equal(second.nextRetryAt, 91_000)
+  assert.equal(second.exhausted, false)
+
+  const third = advanceConnectorReconnectState(second, 'boom-3', 91_000, policy)
+  assert.equal(third.attempts, 3)
+  assert.equal(third.backoffMs, 120_000)
+  assert.equal(third.nextRetryAt, 211_000)
+  assert.equal(third.exhausted, true)
+})
+
+test('createConnectorReconnectState respects custom initial backoff', () => {
+  const state = createConnectorReconnectState(
+    { error: 'seeded' },
+    { initialBackoffMs: 45_000 },
+  )
+
+  assert.equal(state.attempts, 0)
+  assert.equal(state.backoffMs, 45_000)
+  assert.equal(state.nextRetryAt, 0)
+  assert.equal(state.error, 'seeded')
+  assert.equal(state.exhausted, false)
+})