@swarmclawai/swarmclaw 0.8.4 → 0.8.7

package/src/lib/wallet.test.ts

@@ -1,17 +1,333 @@
-import assert from 'node:assert/strict'
 import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import {
+  normalizeWalletChainInput,
+  getWalletChainOrDefault,
+  normalizeAtomicString,
+  parseDisplayAmountToAtomic,
+  formatAtomicAmount,
+  formatWalletAmount,
+  getWalletChainMeta,
+  getWalletDefaultLimitAtomic,
+  getWalletExplorerUrl,
+  getWalletAssetSymbol,
+  getWalletAtomicAmount,
+  getWalletFeeAtomicAmount,
+  getWalletLimitAtomic,
+  getWalletBalanceAtomic,
+} from './wallet'
+
+describe('normalizeWalletChainInput', () => {
+  it('normalizes solana variants', () => {
+    assert.equal(normalizeWalletChainInput('solana'), 'solana')
+    assert.equal(normalizeWalletChainInput('Solana'), 'solana')
+    assert.equal(normalizeWalletChainInput('SOL'), 'solana')
+    assert.equal(normalizeWalletChainInput('sol'), 'solana')
+    assert.equal(normalizeWalletChainInput('  sol  '), 'solana')
+  })
+
+  it('normalizes ethereum variants', () => {
+    assert.equal(normalizeWalletChainInput('ethereum'), 'ethereum')
+    assert.equal(normalizeWalletChainInput('Ethereum'), 'ethereum')
+    assert.equal(normalizeWalletChainInput('ETH'), 'ethereum')
+    assert.equal(normalizeWalletChainInput('eth'), 'ethereum')
+    assert.equal(normalizeWalletChainInput('evm'), 'ethereum')
+    assert.equal(normalizeWalletChainInput('EVM'), 'ethereum')
+  })
+
+  it('returns null for unsupported or empty input', () => {
+    assert.equal(normalizeWalletChainInput('bitcoin'), null)
+    assert.equal(normalizeWalletChainInput(''), null)
+    assert.equal(normalizeWalletChainInput(null), null)
+    assert.equal(normalizeWalletChainInput(undefined), null)
+    assert.equal(normalizeWalletChainInput(0), null)
+    assert.equal(normalizeWalletChainInput(false), null)
+  })
+})
 
-import { getWalletChainOrDefault, parseDisplayAmountToAtomic } from './wallet'
+describe('getWalletChainOrDefault', () => {
+  it('returns recognized chain', () => {
+    assert.equal(getWalletChainOrDefault('sol'), 'solana')
+    assert.equal(getWalletChainOrDefault('eth'), 'ethereum')
+  })
 
-describe('wallet helpers', () => {
-  it('rejects unsupported wallet chain aliases instead of silently remapping them', () => {
+  it('returns fallback for empty/null/undefined', () => {
+    assert.equal(getWalletChainOrDefault(''), 'solana')
+    assert.equal(getWalletChainOrDefault(null), 'solana')
+    assert.equal(getWalletChainOrDefault(undefined), 'solana')
+    assert.equal(getWalletChainOrDefault(undefined, 'ethereum'), 'ethereum')
+  })
+
+  it('throws for unrecognized non-empty value', () => {
+    assert.throws(() => getWalletChainOrDefault('bitcoin'), /Unsupported wallet chain/)
     assert.throws(() => getWalletChainOrDefault('base'), /Unsupported wallet chain or provider: base/)
     assert.throws(() => getWalletChainOrDefault('ethereun'), /Unsupported wallet chain or provider: ethereun/)
-    assert.equal(getWalletChainOrDefault(undefined), 'solana')
+  })
+})
+
+describe('normalizeAtomicString', () => {
+  it('handles string integers', () => {
+    assert.equal(normalizeAtomicString('12345'), '12345')
+    assert.equal(normalizeAtomicString('0'), '0')
+    assert.equal(normalizeAtomicString('007'), '7')
+    assert.equal(normalizeAtomicString('0000'), '0')
+  })
+
+  it('handles bigint', () => {
+    assert.equal(normalizeAtomicString(BigInt(999)), '999')
+    assert.equal(normalizeAtomicString(BigInt(0)), '0')
+    assert.equal(normalizeAtomicString(BigInt(-5)), '0')
+    assert.equal(normalizeAtomicString(BigInt(-1), 'fallback'), 'fallback')
+  })
+
+  it('handles number', () => {
+    assert.equal(normalizeAtomicString(100), '100')
+    assert.equal(normalizeAtomicString(3.9), '3')
+    assert.equal(normalizeAtomicString(0), '0')
   })
 
-  it('parses tiny ETH amounts from either strings or numbers', () => {
+  it('returns fallback for invalid input', () => {
+    assert.equal(normalizeAtomicString('abc'), '0')
+    assert.equal(normalizeAtomicString('12.5'), '0')
+    assert.equal(normalizeAtomicString(-1), '0')
+    assert.equal(normalizeAtomicString(NaN), '0')
+    assert.equal(normalizeAtomicString(Infinity), '0')
+    assert.equal(normalizeAtomicString(null), '0')
+    assert.equal(normalizeAtomicString(undefined), '0')
+    assert.equal(normalizeAtomicString('  '), '0')
+    assert.equal(normalizeAtomicString(null, 'custom'), 'custom')
+  })
+
+  it('strips leading zeros from strings', () => {
+    assert.equal(normalizeAtomicString('00100'), '100')
+    assert.equal(normalizeAtomicString('00'), '0')
+  })
+})
+
+describe('parseDisplayAmountToAtomic', () => {
+  it('converts whole numbers (SOL, 9 decimals)', () => {
+    assert.equal(parseDisplayAmountToAtomic('1', 9), '1000000000')
+    assert.equal(parseDisplayAmountToAtomic('0', 9), '0')
+    assert.equal(parseDisplayAmountToAtomic('100', 9), '100000000000')
+  })
+
+  it('converts fractional numbers (SOL)', () => {
+    assert.equal(parseDisplayAmountToAtomic('0.1', 9), '100000000')
+    assert.equal(parseDisplayAmountToAtomic('1.5', 9), '1500000000')
+    assert.equal(parseDisplayAmountToAtomic('0.000000001', 9), '1')
+  })
+
+  it('converts with ETH decimals (18)', () => {
+    assert.equal(parseDisplayAmountToAtomic('1', 18), '1000000000000000000')
+    assert.equal(parseDisplayAmountToAtomic('0.01', 18), '10000000000000000')
     assert.equal(parseDisplayAmountToAtomic('0.000000000000000001', 18), '1')
+  })
+
+  it('accepts number input', () => {
+    assert.equal(parseDisplayAmountToAtomic(1.5, 9), '1500000000')
+    assert.equal(parseDisplayAmountToAtomic(0, 9), '0')
     assert.equal(parseDisplayAmountToAtomic(0.000000000000000001, 18), '1')
   })
+
+  it('throws for empty amount', () => {
+    assert.throws(() => parseDisplayAmountToAtomic('', 9), /Amount is required/)
+  })
+
+  it('throws for non-numeric strings', () => {
+    assert.throws(() => parseDisplayAmountToAtomic('abc', 9), /Amount must be a positive decimal/)
+    assert.throws(() => parseDisplayAmountToAtomic('-1', 9), /Amount must be a positive decimal/)
+  })
+
+  it('throws for too many decimal places', () => {
+    assert.throws(() => parseDisplayAmountToAtomic('1.0000000001', 9), /up to 9 decimal places/)
+  })
+})
+
+describe('formatAtomicAmount', () => {
+  it('formats SOL (9 decimals)', () => {
+    assert.equal(formatAtomicAmount('1000000000', 9), '1')
+    assert.equal(formatAtomicAmount('1500000000', 9), '1.5')
+    assert.equal(formatAtomicAmount('100000000', 9), '0.1')
+    assert.equal(formatAtomicAmount('1', 9), '0.000000001')
+    assert.equal(formatAtomicAmount('0', 9), '0')
+  })
+
+  it('formats ETH (18 decimals)', () => {
+    assert.equal(formatAtomicAmount('1000000000000000000', 18), '1')
+    assert.equal(formatAtomicAmount('10000000000000000', 18), '0.01')
+  })
+
+  it('respects minFractionDigits', () => {
+    assert.equal(formatAtomicAmount('1000000000', 9, { minFractionDigits: 2 }), '1.00')
+    assert.equal(formatAtomicAmount('1500000000', 9, { minFractionDigits: 4 }), '1.5000')
+  })
+
+  it('respects maxFractionDigits', () => {
+    assert.equal(formatAtomicAmount('1', 9, { maxFractionDigits: 2 }), '0')
+    assert.equal(formatAtomicAmount('1000000000', 9, { maxFractionDigits: 0 }), '1')
+  })
+
+  it('handles bigint input', () => {
+    assert.equal(formatAtomicAmount(BigInt('1000000000'), 9), '1')
+  })
+
+  it('handles number input', () => {
+    assert.equal(formatAtomicAmount(1000000000, 9), '1')
+  })
+})
+
+describe('formatWalletAmount', () => {
+  it('uses chain-specific decimals', () => {
+    assert.equal(formatWalletAmount('solana', '1000000000'), '1')
+    assert.equal(formatWalletAmount('ethereum', '1000000000000000000'), '1')
+  })
+})
+
+describe('getWalletChainMeta', () => {
+  it('returns solana metadata', () => {
+    const meta = getWalletChainMeta('solana')
+    assert.equal(meta.symbol, 'SOL')
+    assert.equal(meta.decimals, 9)
+    assert.equal(meta.chain, 'solana')
+  })
+
+  it('returns ethereum metadata', () => {
+    const meta = getWalletChainMeta('ethereum')
+    assert.equal(meta.symbol, 'ETH')
+    assert.equal(meta.decimals, 18)
+  })
+
+  it('falls back to solana for unknown chain', () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const meta = getWalletChainMeta('unknown' as any)
+    assert.equal(meta.chain, 'solana')
+  })
+})
+
+describe('getWalletDefaultLimitAtomic', () => {
+  it('returns perTx and daily defaults', () => {
+    assert.equal(getWalletDefaultLimitAtomic('solana', 'perTx'), '100000000')
+    assert.equal(getWalletDefaultLimitAtomic('solana', 'daily'), '1000000000')
+    assert.equal(getWalletDefaultLimitAtomic('ethereum', 'perTx'), '10000000000000000')
+    assert.equal(getWalletDefaultLimitAtomic('ethereum', 'daily'), '50000000000000000')
+  })
+})
+
+describe('getWalletExplorerUrl', () => {
+  it('builds address explorer URLs', () => {
+    assert.equal(
+      getWalletExplorerUrl('solana', 'address', 'abc123'),
+      'https://solscan.io/account/abc123',
+    )
+    assert.equal(
+      getWalletExplorerUrl('ethereum', 'address', '0xdef'),
+      'https://etherscan.io/address/0xdef',
+    )
+  })
+
+  it('builds transaction explorer URLs', () => {
+    assert.equal(
+      getWalletExplorerUrl('solana', 'transaction', 'tx1'),
+      'https://solscan.io/tx/tx1',
+    )
+    assert.equal(
+      getWalletExplorerUrl('ethereum', 'transaction', '0xtx'),
+      'https://etherscan.io/tx/0xtx',
+    )
+  })
+})
+
+describe('getWalletAssetSymbol', () => {
+  it('returns chain symbols', () => {
+    assert.equal(getWalletAssetSymbol('solana'), 'SOL')
+    assert.equal(getWalletAssetSymbol('ethereum'), 'ETH')
+  })
+})
+
+describe('getWalletAtomicAmount', () => {
+  it('prefers amountAtomic', () => {
+    assert.equal(getWalletAtomicAmount({ amountAtomic: '500' }), '500')
+  })
+
+  it('falls back to amountLamports', () => {
+    assert.equal(getWalletAtomicAmount({ amountLamports: 300 }), '300')
+  })
+
+  it('returns 0 for null/undefined', () => {
+    assert.equal(getWalletAtomicAmount(null), '0')
+    assert.equal(getWalletAtomicAmount(undefined), '0')
+  })
+
+  it('returns 0 for empty object', () => {
+    assert.equal(getWalletAtomicAmount({}), '0')
+  })
+})
+
+describe('getWalletFeeAtomicAmount', () => {
+  it('prefers feeAtomic', () => {
+    assert.equal(getWalletFeeAtomicAmount({ feeAtomic: '5000' }), '5000')
+  })
+
+  it('falls back to feeLamports', () => {
+    assert.equal(getWalletFeeAtomicAmount({ feeLamports: 5000 }), '5000')
+  })
+
+  it('returns 0 for null/undefined', () => {
+    assert.equal(getWalletFeeAtomicAmount(null), '0')
+    assert.equal(getWalletFeeAtomicAmount(undefined), '0')
+  })
+})
+
+describe('getWalletLimitAtomic', () => {
+  it('uses spendingLimitAtomic for perTx', () => {
+    assert.equal(
+      getWalletLimitAtomic({ chain: 'solana', spendingLimitAtomic: '50000' }, 'perTx'),
+      '50000',
+    )
+  })
+
+  it('falls back to spendingLimitLamports then default for perTx', () => {
+    assert.equal(
+      getWalletLimitAtomic({ chain: 'solana', spendingLimitLamports: 25000 }, 'perTx'),
+      '25000',
+    )
+    assert.equal(
+      getWalletLimitAtomic({ chain: 'solana' }, 'perTx'),
+      '100000000',
+    )
+  })
+
+  it('uses dailyLimitAtomic for daily', () => {
+    assert.equal(
+      getWalletLimitAtomic({ chain: 'ethereum', dailyLimitAtomic: '99999' }, 'daily'),
+      '99999',
+    )
+  })
+
+  it('falls back for daily', () => {
+    assert.equal(
+      getWalletLimitAtomic({ chain: 'ethereum' }, 'daily'),
+      '50000000000000000',
+    )
+  })
+})
+
+describe('getWalletBalanceAtomic', () => {
+  it('prefers balanceAtomic', () => {
+    assert.equal(getWalletBalanceAtomic({ balanceAtomic: '12345' }), '12345')
+  })
+
+  it('falls back to balanceLamports', () => {
+    assert.equal(getWalletBalanceAtomic({ balanceLamports: 9999 }), '9999')
+  })
+
+  it('returns 0 for null/undefined/empty', () => {
+    assert.equal(getWalletBalanceAtomic(null), '0')
+    assert.equal(getWalletBalanceAtomic(undefined), '0')
+    assert.equal(getWalletBalanceAtomic({}), '0')
+  })
+
+  it('handles null balanceLamports', () => {
+    assert.equal(getWalletBalanceAtomic({ balanceLamports: null }), '0')
+  })
 })

package/src/proxy.test.ts

@@ -45,8 +45,8 @@ describe('proxy', () => {
 
   it('does not lock out invalid requests in development', () => {
     process.env.ACCESS_KEY = 'top-secret'
-    const originalNodeEnv = process.env.NODE_ENV
-    process.env.NODE_ENV = 'development'
+    const originalNodeEnv = process.env.NODE_ENV;
+    (process.env as any).NODE_ENV = 'development'
 
     try {
       for (let i = 0; i < 6; i++) {
@@ -64,8 +64,8 @@ describe('proxy', () => {
       }))
       assert.equal(finalResponse.status, 401)
     } finally {
-      if (originalNodeEnv === undefined) delete process.env.NODE_ENV
-      else process.env.NODE_ENV = originalNodeEnv
+      if (originalNodeEnv === undefined) delete (process.env as any).NODE_ENV
+      else (process.env as any).NODE_ENV = originalNodeEnv
     }
   })
 })

package/src/proxy.ts

@@ -7,6 +7,7 @@ import {
   resolvePluginInstallCorsOrigin,
 } from '@/lib/plugin-install-cors'
 import { isProductionRuntime } from '@/lib/runtime-env'
+import { hmrSingleton } from '@/lib/shared-utils'
 
 /* ------------------------------------------------------------------ */
 /*  Rate-limit state — HMR-safe via globalThis                        */
@@ -17,9 +18,7 @@ interface RateLimitEntry {
   lockedUntil: number
 }
 
-const rateLimitMap = (
-  (globalThis as Record<string, unknown>).__swarmclaw_rate_limit__ ??= new Map()
-) as Map<string, RateLimitEntry>
+const rateLimitMap = hmrSingleton('__swarmclaw_rate_limit__', () => new Map<string, RateLimitEntry>())
 
 const MAX_ATTEMPTS = 5
 const LOCKOUT_MS = 15 * 60 * 1000 // 15 minutes

package/src/stores/set-if-changed.ts

@@ -0,0 +1,40 @@
+/**
+ * Memoisation layer for Zustand store loaders.
+ *
+ * Every async loader (loadSessions, loadTasks, loadProviders, …) fetches data
+ * from the API and calls `set()`. Because the API always returns fresh object
+ * references, `set()` unconditionally replaces the store value, which triggers
+ * re-renders in *every* component that subscribes to that slice — even when the
+ * data hasn't changed.
+ *
+ * `setIfChanged` keeps a lightweight JSON fingerprint of the last value written
+ * for each store key. If the new value produces the same fingerprint, the
+ * `set()` call is skipped entirely, preventing the render cascade.
+ */
+
+const fingerprints = new Map<string, string>()
+
+/**
+ * Call Zustand `set()` only when the value for `key` has actually changed.
+ * Returns `true` if `set()` was called, `false` if skipped.
+ */
+export function setIfChanged<S>(
+  set: (partial: Partial<S>) => void,
+  key: keyof S & string,
+  value: S[keyof S],
+): boolean {
+  const json = JSON.stringify(value)
+  if (fingerprints.get(key) === json) return false
+  fingerprints.set(key, json)
+  set({ [key]: value } as Partial<S>)
+  return true
+}
+
+/**
+ * Invalidate the fingerprint for a key so the next `setIfChanged` call
+ * for that key will always write. Useful after local mutations (optimistic
+ * updates, removes) that change the store without going through the loader.
+ */
+export function invalidateFingerprint(key: string): void {
+  fingerprints.delete(key)
+}

package/src/stores/slices/agent-slice.ts

@@ -0,0 +1,111 @@
+const inflightAgentThreadLoads = new Map<string, Promise<void>>()
+import { StateCreator } from 'zustand'
+import type { AppState } from '../use-app-store'
+import type { Session, Agent, ExternalAgentRuntime } from '../../types'
+import { fetchAgents } from '../../lib/agents'
+import { findLatestObservablePlatformSession, isLocalhostBrowser } from '../../lib/local-observability'
+import { api } from '../../lib/api-client'
+import { safeStorageRemove, safeStorageSet } from '../../lib/safe-storage'
+import { setIfChanged, invalidateFingerprint } from '../set-if-changed'
+
+export interface AgentSlice {
+  currentAgentId: string | null
+  setCurrentAgent: (id: string | null) => Promise<void>
+  agents: Record<string, Agent>
+  loadAgents: () => Promise<void>
+  togglePinAgent: (id: string) => void
+  trashedAgents: Record<string, Agent>
+  loadTrashedAgents: () => Promise<void>
+  externalAgents: ExternalAgentRuntime[]
+  loadExternalAgents: () => Promise<void>
+}
+
+export const createAgentSlice: StateCreator<AppState, [], [], AgentSlice> = (set, get) => ({
+  currentAgentId: null,
+  setCurrentAgent: async (id) => {
+    if (!id) {
+      set({ currentAgentId: null })
+      safeStorageRemove('sc_agent')
+      return
+    }
+    const currentState = get()
+    const currentSession = currentState.currentSessionId ? currentState.sessions[currentState.currentSessionId] : null
+    if (currentState.currentAgentId === id && currentSession?.agentId === id) {
+      return
+    }
+    set({ currentAgentId: id })
+    safeStorageSet('sc_agent', id)
+    if (isLocalhostBrowser()) {
+      const livePlatformSession = findLatestObservablePlatformSession(get().sessions, id)
+      if (livePlatformSession?.id) {
+        set({ currentSessionId: livePlatformSession.id })
+        return
+      }
+    }
+
+    const existingLoad = inflightAgentThreadLoads.get(id)
+    if (existingLoad) {
+      await existingLoad
+      return
+    }
+
+    const loadPromise = (async () => {
+      try {
+        const user = get().currentUser || 'default'
+        const session = await api<Session>('POST', `/agents/${id}/thread`, { user })
+        if (session?.id) {
+          const sessions = { ...get().sessions, [session.id]: session }
+          invalidateFingerprint('sessions')
+          set({ sessions, currentSessionId: session.id })
+        }
+      } catch {
+        // ignore — thread creation failed
+      }
+    })()
+
+    inflightAgentThreadLoads.set(id, loadPromise)
+    try {
+      await loadPromise
+    } finally {
+      if (inflightAgentThreadLoads.get(id) === loadPromise) {
+        inflightAgentThreadLoads.delete(id)
+      }
+    }
+  },
+  agents: {},
+  loadAgents: async () => {
+    try {
+      const agents = await fetchAgents()
+      setIfChanged<AppState>(set, 'agents', agents)
+    } catch (err) {
+      console.warn('Store error:', err)
+    }
+  },
+  togglePinAgent: (id) => {
+    const agents = { ...get().agents }
+    if (agents[id]) {
+      agents[id] = { ...agents[id], pinned: !agents[id].pinned }
+      invalidateFingerprint('agents')
+      set({ agents })
+      void api('PUT', `/agents/${id}`, { pinned: agents[id].pinned })
+    }
+  },
+  trashedAgents: {},
+  loadTrashedAgents: async () => {
+    try {
+      const trashedAgents = await api<Record<string, Agent>>('GET', '/agents/trash')
+      setIfChanged<AppState>(set, 'trashedAgents', trashedAgents)
+    } catch (err) {
+      console.warn('Store error:', err)
+    }
+  },
+  externalAgents: [],
+  loadExternalAgents: async () => {
+    try {
+      const externalAgents = await api<ExternalAgentRuntime[]>('GET', '/external-agents')
+      setIfChanged<AppState>(set, 'externalAgents', externalAgents)
+    } catch (err) {
+      console.warn('Store error:', err)
+    }
+  }
+})

package/src/stores/slices/auth-slice.ts

@@ -0,0 +1,25 @@
+import { StateCreator } from 'zustand'
+import type { AppState } from '../use-app-store'
+import { safeStorageGet, safeStorageRemove, safeStorageSet } from '../../lib/safe-storage'
+
+export interface AuthSlice {
+  currentUser: string | null
+  _hydrated: boolean
+  hydrate: () => void
+  setUser: (user: string | null) => void
+}
+
+export const createAuthSlice: StateCreator<AppState, [], [], AuthSlice> = (set, get) => ({
+  currentUser: null,
+  _hydrated: false,
+  hydrate: () => {
+    const user = safeStorageGet('sc_user')
+    const savedAgentId = safeStorageGet('sc_agent')
+    set({ currentUser: user, currentAgentId: savedAgentId, _hydrated: true })
+  },
+  setUser: (user) => {
+    if (user) safeStorageSet('sc_user', user)
+    else safeStorageRemove('sc_user')
+    set({ currentUser: user })
+  }
+})