@swarmclawai/swarmclaw 0.7.2 → 0.7.4

package/src/lib/server/memory-db.ts

@@ -14,6 +14,7 @@ import {
   traverseLinkedMemoryGraph,
   type MemoryLookupLimits,
 } from './memory-graph'
+import { isWorkingMemoryCategory } from './memory-tiers'
 
 import { DATA_DIR } from './data-dir'
 
@@ -1203,8 +1204,7 @@ function initDb() {
         if (seenCanonical.has(keyCanonical)) canonicalDuplicateCandidates++
         else seenCanonical.add(keyCanonical)
 
-        const category = String(row.category || '').toLowerCase()
-        const isWorkingLike = category === 'execution' || category === 'working' || category === 'scratch'
+        const isWorkingLike = isWorkingMemoryCategory(row.category)
         if (isWorkingLike && (row.updatedAt || row.createdAt || 0) < cutoff) staleWorkingCandidates++
       }
 
@@ -1303,8 +1303,7 @@ function initDb() {
       if (pruneWorking && toDelete.size < deleteBudget) {
         for (const row of rows) {
           if (toDelete.has(row.id)) continue
-          const category = String(row.category || '').toLowerCase()
-          const isWorkingLike = category === 'execution' || category === 'working' || category === 'scratch'
+          const isWorkingLike = isWorkingMemoryCategory(row.category)
           const updatedAt = row.updatedAt || row.createdAt || 0
           if (isWorkingLike && updatedAt < cutoff) toDelete.add(row.id)
           if (toDelete.size >= deleteBudget) break
@@ -1323,8 +1322,7 @@ function initDb() {
         const deletedSet = new Set(deleteIds)
         for (const row of rows) {
           if (!deletedSet.has(row.id)) continue
-          const category = String(row.category || '').toLowerCase()
-          const isWorkingLike = category === 'execution' || category === 'working' || category === 'scratch'
+          const isWorkingLike = isWorkingMemoryCategory(row.category)
           if (isWorkingLike) pruned++
           else deduped++
         }

package/src/lib/server/memory-tiers.ts

@@ -0,0 +1,40 @@
+import type { MemoryEntry } from '@/types'
+
+export type MemoryTier = 'working' | 'durable' | 'archive'
+
+const WORKING_CATEGORIES = new Set(['execution', 'working', 'scratch', 'breadcrumb'])
+const ARCHIVE_CATEGORIES = new Set(['session_archive'])
+
+export function getMemoryTierForCategory(category: unknown): MemoryTier {
+  const normalized = typeof category === 'string' ? category.trim().toLowerCase() : ''
+  if (ARCHIVE_CATEGORIES.has(normalized)) return 'archive'
+  if (WORKING_CATEGORIES.has(normalized)) return 'working'
+  return 'durable'
+}
+
+export function getMemoryTier(entry: Pick<MemoryEntry, 'category' | 'metadata'>): MemoryTier {
+  const metadataTier = typeof entry.metadata?.tier === 'string' ? entry.metadata.tier.trim().toLowerCase() : ''
+  if (metadataTier === 'archive' || metadataTier === 'session_archive') return 'archive'
+  if (metadataTier === 'working') return 'working'
+  if (metadataTier === 'durable') return 'durable'
+  return getMemoryTierForCategory(entry.category)
+}
+
+export function partitionMemoriesByTier<T extends Pick<MemoryEntry, 'category' | 'metadata'>>(entries: T[]) {
+  const working: T[] = []
+  const durable: T[] = []
+  const archive: T[] = []
+
+  for (const entry of entries) {
+    const tier = getMemoryTier(entry)
+    if (tier === 'working') working.push(entry)
+    else if (tier === 'archive') archive.push(entry)
+    else durable.push(entry)
+  }
+
+  return { working, durable, archive }
+}
+
+export function isWorkingMemoryCategory(category: unknown): boolean {
+  return getMemoryTierForCategory(category) === 'working'
+}

package/src/lib/server/openclaw-agent-resolver.test.ts

@@ -0,0 +1,70 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import type { Agent } from '@/types'
+import {
+  resolveOpenClawGatewayAgentIdFromList,
+  type OpenClawGatewayAgentSummary,
+} from './openclaw-agent-resolver'
+
+function makeOpenClawAgent(overrides: Partial<Agent> = {}): Agent {
+  const now = Date.now()
+  return {
+    id: 'f4535f26',
+    name: 'OpenClaw Ops',
+    description: '',
+    systemPrompt: '',
+    provider: 'openclaw',
+    model: 'openclaw-default',
+    createdAt: now,
+    updatedAt: now,
+    ...overrides,
+  }
+}
+
+test('resolveOpenClawGatewayAgentIdFromList matches a local OpenClaw agent by normalized name', () => {
+  const gatewayAgents: OpenClawGatewayAgentSummary[] = [
+    { id: 'main', name: 'Main' },
+    { id: 'openclaw-ops', name: 'OpenClaw Ops' },
+  ]
+  const resolved = resolveOpenClawGatewayAgentIdFromList({
+    agentRef: 'f4535f26',
+    gatewayAgents,
+    localAgent: makeOpenClawAgent(),
+  })
+  assert.equal(resolved, 'openclaw-ops')
+})
+
+test('resolveOpenClawGatewayAgentIdFromList preserves direct gateway ids', () => {
+  const gatewayAgents: OpenClawGatewayAgentSummary[] = [
+    { id: 'main', name: 'Main' },
+  ]
+  const resolved = resolveOpenClawGatewayAgentIdFromList({
+    agentRef: 'main',
+    gatewayAgents,
+  })
+  assert.equal(resolved, 'main')
+})
+
+test('resolveOpenClawGatewayAgentIdFromList can match identity names when display names differ', () => {
+  const gatewayAgents: OpenClawGatewayAgentSummary[] = [
+    { id: 'research-ops', identity: { name: 'Research Ops' } },
+  ]
+  const resolved = resolveOpenClawGatewayAgentIdFromList({
+    agentRef: 'agent-123',
+    gatewayAgents,
+    localAgent: makeOpenClawAgent({ id: 'agent-123', name: 'Research Ops' }),
+  })
+  assert.equal(resolved, 'research-ops')
+})
+
+test('single-agent gateway can back a local OpenClaw provider agent without an explicit name match', async () => {
+  const gatewayAgents: OpenClawGatewayAgentSummary[] = [
+    { id: 'main', name: 'Main' },
+  ]
+  const resolved = resolveOpenClawGatewayAgentIdFromList({
+    agentRef: 'f4535f26',
+    gatewayAgents,
+    localAgent: makeOpenClawAgent({ name: 'OpenClaw-2' }),
+  })
+  assert.equal(resolved, 'main')
+})

package/src/lib/server/openclaw-agent-resolver.ts

@@ -0,0 +1,128 @@
+import type { Agent } from '@/types'
+import { normalizeOpenClawAgentId } from '@/lib/openclaw-agent-id'
+import { ensureGatewayConnected, type OpenClawGateway } from './openclaw-gateway'
+import { loadAgents } from './storage'
+
+export interface OpenClawGatewayAgentSummary {
+  id: string
+  name?: string
+  identity?: {
+    name?: string
+  } | null
+}
+
+interface OpenClawGatewayAgentsList {
+  defaultId?: string
+  agents?: OpenClawGatewayAgentSummary[]
+}
+
+function addTextCandidate(target: Set<string>, value: string | undefined | null) {
+  const trimmed = (value ?? '').trim()
+  if (trimmed) {
+    target.add(trimmed.toLowerCase())
+  }
+}
+
+function addNormalizedCandidate(target: Set<string>, value: string | undefined | null) {
+  const trimmed = (value ?? '').trim()
+  if (trimmed) {
+    target.add(normalizeOpenClawAgentId(trimmed))
+  }
+}
+
+export function resolveOpenClawGatewayAgentIdFromList(params: {
+  agentRef: string
+  gatewayAgents: OpenClawGatewayAgentSummary[]
+  localAgent?: Agent | null
+}): string | null {
+  const rawRef = params.agentRef.trim()
+  if (!rawRef) {
+    return null
+  }
+
+  const exactTextCandidates = new Set<string>()
+  const normalizedCandidates = new Set<string>()
+
+  addTextCandidate(exactTextCandidates, rawRef)
+  addNormalizedCandidate(normalizedCandidates, rawRef)
+
+  if (params.localAgent) {
+    addTextCandidate(exactTextCandidates, params.localAgent.id)
+    addTextCandidate(exactTextCandidates, params.localAgent.name)
+    addNormalizedCandidate(normalizedCandidates, params.localAgent.id)
+    addNormalizedCandidate(normalizedCandidates, params.localAgent.name)
+  }
+
+  for (const gatewayAgent of params.gatewayAgents) {
+    if (exactTextCandidates.has(gatewayAgent.id.trim().toLowerCase())) {
+      return gatewayAgent.id
+    }
+  }
+
+  for (const gatewayAgent of params.gatewayAgents) {
+    if (normalizedCandidates.has(normalizeOpenClawAgentId(gatewayAgent.id))) {
+      return gatewayAgent.id
+    }
+  }
+
+  for (const gatewayAgent of params.gatewayAgents) {
+    const labels = [gatewayAgent.name, gatewayAgent.identity?.name]
+    for (const label of labels) {
+      if (!label?.trim()) continue
+      if (exactTextCandidates.has(label.trim().toLowerCase())) {
+        return gatewayAgent.id
+      }
+    }
+  }
+
+  for (const gatewayAgent of params.gatewayAgents) {
+    const labels = [gatewayAgent.name, gatewayAgent.identity?.name]
+    for (const label of labels) {
+      if (!label?.trim()) continue
+      if (normalizedCandidates.has(normalizeOpenClawAgentId(label))) {
+        return gatewayAgent.id
+      }
+    }
+  }
+
+  if (params.localAgent && params.gatewayAgents.length === 1) {
+    return params.gatewayAgents[0].id
+  }
+
+  return null
+}
+
+export async function resolveOpenClawGatewayAgentId(
+  agentRef: string,
+  gatewayArg?: OpenClawGateway | null,
+): Promise<string> {
+  const trimmedRef = agentRef.trim()
+  if (!trimmedRef) {
+    throw new Error('Missing agentId')
+  }
+
+  const localAgents = loadAgents({ includeTrashed: true }) as Record<string, Agent>
+  const localAgent = localAgents[trimmedRef] || null
+  if (localAgent && localAgent.provider !== 'openclaw') {
+    throw new Error(`Agent "${localAgent.name}" is not an OpenClaw agent`)
+  }
+
+  const gateway = gatewayArg ?? await ensureGatewayConnected()
+  if (!gateway) {
+    throw new Error('OpenClaw gateway not connected')
+  }
+
+  const result = await gateway.rpc('agents.list', {}) as OpenClawGatewayAgentsList | undefined
+  const gatewayAgents = Array.isArray(result?.agents) ? result.agents : []
+  const resolved = resolveOpenClawGatewayAgentIdFromList({
+    agentRef: trimmedRef,
+    gatewayAgents,
+    localAgent,
+  })
+  if (resolved) {
+    return resolved
+  }
+
+  const label = localAgent?.name?.trim() || trimmedRef
+  throw new Error(`OpenClaw gateway agent not found for "${label}"`)
+}

package/src/lib/server/openclaw-exec-config.ts

@@ -7,12 +7,13 @@ const DEFAULT_CONFIG: ExecApprovalConfig = {
   patterns: [],
 }
 
-/** Fetch exec approval config from gateway for a given agent */
-export async function getExecConfig(agentId: string): Promise<ExecApprovalSnapshot> {
+/** Fetch the gateway's global exec approval config. */
+export async function getExecConfig(agentId?: string): Promise<ExecApprovalSnapshot> {
+  void agentId
   const gw = await ensureGatewayConnected()
   if (!gw) throw new Error('Gateway not connected')
 
-  const result = await gw.rpc('exec.approvals.get', { agentId }) as ExecApprovalSnapshot | undefined
+  const result = await gw.rpc('exec.approvals.get', {}) as ExecApprovalSnapshot | undefined
   if (!result) {
     return { path: '', exists: false, hash: '', file: { ...DEFAULT_CONFIG } }
   }
@@ -25,6 +26,7 @@ export async function setExecConfig(
   config: ExecApprovalConfig,
   baseHash: string,
 ): Promise<{ ok: boolean; hash: string }> {
+  void agentId
   const gw = await ensureGatewayConnected()
   if (!gw) throw new Error('Gateway not connected')
 
@@ -32,7 +34,6 @@ export async function setExecConfig(
   for (let attempt = 0; attempt < 3; attempt++) {
     try {
       const result = await gw.rpc('exec.approvals.set', {
-        agentId,
         file: config,
         baseHash: currentHash,
       }) as { hash?: string } | undefined
@@ -41,7 +42,7 @@ export async function setExecConfig(
       const msg = err instanceof Error ? err.message : String(err)
       if (msg.includes('conflict') && attempt < 2) {
         // Re-fetch to get fresh hash
-        const fresh = await getExecConfig(agentId)
+        const fresh = await getExecConfig()
         currentHash = fresh.hash
         continue
       }

package/src/lib/server/openclaw-gateway.ts

@@ -3,6 +3,7 @@ import { randomUUID } from 'crypto'
 import { wsConnect, buildOpenClawConnectParams } from '../providers/openclaw'
 import { loadAgents, loadCredentials, decryptKey } from './storage'
 import { notify, notifyWithPayload } from './ws-hub'
+import { getGatewayProfile, getGatewayProfiles, resolvePrimaryAgentRoute } from './agent-runtime-config'
 
 // --- Types ---
 
@@ -19,19 +20,22 @@ type EventHandler = (payload: unknown) => void
 const GK = '__swarmclaw_ocgateway__' as const
 
 interface GatewayState {
-  instance: OpenClawGateway | null
+  instances: Map<string, OpenClawGateway>
+  activeKey: string | null
 }
 
 function getState(): GatewayState {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   const g = globalThis as any
-  if (!g[GK]) g[GK] = { instance: null }
+  if (!g[GK]) g[GK] = { instances: new Map<string, OpenClawGateway>(), activeKey: null }
   return g[GK] as GatewayState
 }
 
 // --- Helper: resolve gateway config from first OpenClaw agent ---
 
 interface GatewayConfig {
+  key: string
+  profileId?: string | null
   wsUrl: string
   token: string | undefined
 }
@@ -43,27 +47,79 @@ function normalizeWsUrl(raw: string): string {
   return url.replace(/^http:/i, 'ws:').replace(/^https:/i, 'wss:')
 }
 
-export function resolveGatewayConfig(): GatewayConfig | null {
-  const agents = loadAgents({ includeTrashed: true })
+function resolveTokenForCredential(credentialId?: string | null): string | undefined {
+  const id = typeof credentialId === 'string' && credentialId.trim() ? credentialId.trim() : ''
+  if (!id) return undefined
   const creds = loadCredentials()
+  const cred = creds[id]
+  if (!cred?.encryptedKey) return undefined
+  try {
+    return decryptKey(cred.encryptedKey)
+  } catch {
+    return undefined
+  }
+}
+
+export function resolveGatewayConfig(target?: {
+  profileId?: string | null
+  agentId?: string | null
+}): GatewayConfig | null {
+  const profileId = typeof target?.profileId === 'string' ? target.profileId.trim() : ''
+  if (profileId) {
+    const profile = getGatewayProfile(profileId)
+    if (!profile) return null
+    return {
+      key: `profile:${profile.id}`,
+      profileId: profile.id,
+      wsUrl: profile.wsUrl ? normalizeWsUrl(profile.wsUrl) : normalizeWsUrl(profile.endpoint),
+      token: resolveTokenForCredential(profile.credentialId),
+    }
+  }
+
+  const agentId = typeof target?.agentId === 'string' ? target.agentId.trim() : ''
+  if (agentId) {
+    const agents = loadAgents({ includeTrashed: true })
+    const agent = agents[agentId]
+    const route = resolvePrimaryAgentRoute(agent)
+    if (route?.provider === 'openclaw') {
+      return {
+        key: route.gatewayProfileId ? `profile:${route.gatewayProfileId}` : `agent:${agentId}`,
+        profileId: route.gatewayProfileId ?? null,
+        wsUrl: normalizeWsUrl(route.apiEndpoint || 'ws://127.0.0.1:18789'),
+        token: resolveTokenForCredential(route.credentialId),
+      }
+    }
+  }
+
+  const gatewayProfiles = getGatewayProfiles('openclaw')
+  if (gatewayProfiles[0]) {
+    const profile = gatewayProfiles[0]
+    return {
+      key: `profile:${profile.id}`,
+      profileId: profile.id,
+      wsUrl: profile.wsUrl ? normalizeWsUrl(profile.wsUrl) : normalizeWsUrl(profile.endpoint),
+      token: resolveTokenForCredential(profile.credentialId),
+    }
+  }
+
+  const agents = loadAgents({ includeTrashed: true })
   for (const agent of Object.values(agents)) {
     if (agent?.provider !== 'openclaw') continue
     const wsUrl = agent.apiEndpoint
       ? normalizeWsUrl(agent.apiEndpoint)
       : 'ws://127.0.0.1:18789'
-    let token: string | undefined
-    if (agent.credentialId) {
-      const cred = creds[agent.credentialId]
-      if (cred?.encryptedKey) {
-        try { token = decryptKey(cred.encryptedKey) } catch { /* ignore */ }
-      }
+    return {
+      key: `agent:${agent.id}`,
+      profileId: agent.gatewayProfileId ?? null,
+      wsUrl,
+      token: resolveTokenForCredential(agent.credentialId),
     }
-    return { wsUrl, token }
   }
   return null
 }
 
 export function hasOpenClawAgents(): boolean {
+  if (getGatewayProfiles('openclaw').length > 0) return true
   const agents = loadAgents({ includeTrashed: true })
   return Object.values(agents).some((a) => a?.provider === 'openclaw' && !a.trashedAt)
 }
@@ -253,47 +309,78 @@ export class OpenClawGateway {
 
 // --- Singleton access ---
 
-export function getGateway(): OpenClawGateway | null {
-  return getState().instance
+export function getGateway(profileId?: string | null): OpenClawGateway | null {
+  const state = getState()
+  const key = typeof profileId === 'string' && profileId.trim() ? `profile:${profileId.trim()}` : null
+  if (key) {
+    return state.instances.get(key) || null
+  }
+  if (state.activeKey) {
+    return state.instances.get(state.activeKey) || null
+  }
+  for (const instance of state.instances.values()) {
+    if (instance.connected) return instance
+  }
+  return null
 }
 
-export async function ensureGatewayConnected(): Promise<OpenClawGateway | null> {
+export async function ensureGatewayConnected(target?: {
+  profileId?: string | null
+  agentId?: string | null
+}): Promise<OpenClawGateway | null> {
   const state = getState()
-  if (state.instance?.connected) return state.instance
-
-  const config = resolveGatewayConfig()
+  const config = resolveGatewayConfig(target)
   if (!config) return null
-
-  if (!state.instance) {
-    state.instance = new OpenClawGateway()
+  const existing = state.instances.get(config.key)
+  if (existing?.connected) {
+    state.activeKey = config.key
+    return existing
   }
 
-  const ok = await state.instance.connect(config.wsUrl, config.token)
-  return ok ? state.instance : null
+  const instance = existing || new OpenClawGateway()
+  state.instances.set(config.key, instance)
+  const ok = await instance.connect(config.wsUrl, config.token)
+  if (ok) {
+    state.activeKey = config.key
+    return instance
+  }
+  return null
 }
 
-export function disconnectGateway() {
+export function disconnectGateway(profileId?: string | null) {
   const state = getState()
-  if (state.instance) {
-    state.instance.disconnect()
-    state.instance = null
+  const key = typeof profileId === 'string' && profileId.trim() ? `profile:${profileId.trim()}` : null
+  if (key) {
+    const instance = state.instances.get(key)
+    if (instance) {
+      instance.disconnect()
+      state.instances.delete(key)
+      if (state.activeKey === key) state.activeKey = null
+    }
+    return
+  }
+  for (const [instanceKey, instance] of state.instances.entries()) {
+    instance.disconnect()
+    state.instances.delete(instanceKey)
   }
+  state.activeKey = null
 }
 
 /** Manual connect with explicit URL/token (used by gateway connection panel) */
-export async function manualConnect(url?: string, token?: string): Promise<boolean> {
+export async function manualConnect(url?: string, token?: string, profileId?: string | null): Promise<boolean> {
   const state = getState()
-  if (state.instance?.connected) {
-    state.instance.disconnect()
+  const config = resolveGatewayConfig({ profileId: profileId || null })
+  const key = profileId ? `profile:${profileId}` : '__manual__'
+  const instance = state.instances.get(key) || new OpenClawGateway()
+  if (instance.connected) {
+    instance.disconnect()
   }
-
-  const config = resolveGatewayConfig()
+  state.instances.set(key, instance)
   const wsUrl = url ? normalizeWsUrl(url) : config?.wsUrl ?? 'ws://127.0.0.1:18789'
   const resolvedToken = token ?? config?.token
-
-  if (!state.instance) {
-    state.instance = new OpenClawGateway()
+  const ok = await instance.connect(wsUrl, resolvedToken)
+  if (ok) {
+    state.activeKey = key
   }
-
-  return state.instance.connect(wsUrl, resolvedToken)
+  return ok
 }

package/src/lib/server/openclaw-skills-normalize.test.ts

@@ -0,0 +1,56 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { normalizeOpenClawSkillsPayload } from './openclaw-skills-normalize'
+
+test('normalizeOpenClawSkillsPayload maps gateway skill reports into UI entries', () => {
+  const normalized = normalizeOpenClawSkillsPayload({
+    workspaceDir: '/tmp/workspace',
+    skills: [
+      {
+        name: 'github',
+        description: 'GitHub operations',
+        source: 'openclaw-bundled',
+        eligible: true,
+        requirements: {
+          bins: ['gh'],
+          anyBins: [['git', 'jj']],
+          env: ['GH_TOKEN'],
+        },
+        missing: {
+          config: ['channels.github'],
+        },
+        install: [
+          { kind: 'brew', label: 'Install GitHub CLI', bins: ['gh'] },
+        ],
+        configChecks: [
+          { path: 'channels.github', satisfied: false },
+        ],
+        skillKey: 'github',
+        baseDir: '/tmp/github',
+      },
+    ],
+  })
+
+  assert.equal(normalized.length, 1)
+  assert.deepEqual(normalized[0], {
+    name: 'github',
+    description: 'GitHub operations',
+    source: 'bundled',
+    eligible: true,
+    missing: ['config channels.github'],
+    disabled: false,
+    installOptions: [
+      { kind: 'brew', label: 'Install GitHub CLI', bins: ['gh'] },
+    ],
+    skillRequirements: {
+      bins: ['gh'],
+      anyBins: [['git', 'jj']],
+      env: ['GH_TOKEN'],
+      config: undefined,
+      os: undefined,
+    },
+    configChecks: [{ key: 'channels.github', ok: false }],
+    skillKey: 'github',
+    baseDir: '/tmp/github',
+  })
+})