@swarmclawai/swarmclaw 1.2.4 → 1.2.6

package/src/features/skills/queries.ts

@@ -0,0 +1,182 @@
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
+import { api } from '@/lib/app/api-client'
+import type {
+  ClawHubSkill,
+  Skill,
+  SkillInvocationConfig,
+  SkillCommandDispatch,
+  SkillSuggestion,
+} from '@/types'
+
+type QueryOptions = {
+  enabled?: boolean
+}
+
+export interface ClawHubSearchResponse {
+  skills: ClawHubSkill[]
+  total: number
+  page: number
+  nextCursor?: string | null
+  error?: string
+}
+
+export type ClawHubPreview = Partial<Skill> & {
+  name: string
+  content: string
+  description?: string
+  invocation?: SkillInvocationConfig | null
+  commandDispatch?: SkillCommandDispatch | null
+}
+
+async function invalidateSkillQueries(queryClient: ReturnType<typeof useQueryClient>) {
+  await queryClient.invalidateQueries({ queryKey: skillQueryKeys.all })
+}
+
+export const skillQueryKeys = {
+  all: ['skills'] as const,
+}
+
+export const skillSuggestionQueryKeys = {
+  all: ['skill-suggestions'] as const,
+}
+
+export function useSkillsQuery(options: QueryOptions = {}) {
+  return useQuery<Record<string, Skill>>({
+    queryKey: skillQueryKeys.all,
+    queryFn: () => api<Record<string, Skill>>('GET', '/skills'),
+    enabled: options.enabled,
+    staleTime: 20_000,
+  })
+}
+
+export function useSkillSuggestionsQuery(options: QueryOptions = {}) {
+  return useQuery<SkillSuggestion[]>({
+    queryKey: skillSuggestionQueryKeys.all,
+    queryFn: () => api<SkillSuggestion[]>('GET', '/skill-suggestions'),
+    enabled: options.enabled,
+    staleTime: 20_000,
+  })
+}
+
+export function useImportSkillFromUrlMutation() {
+  return useMutation({
+    mutationFn: (url: string) =>
+      api<Partial<Skill> & { name: string; filename: string; description?: string; content: string; sourceFormat?: 'openclaw' | 'plain' }>(
+        'POST',
+        '/skills/import',
+        { url },
+      ),
+  })
+}
+
+export function useSaveSkillMutation() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: ({
+      id,
+      data,
+    }: {
+      id?: string | null
+      data: Record<string, unknown>
+    }) => (id ? api('PUT', `/skills/${id}`, data) : api('POST', '/skills', data)),
+    onSuccess: async () => {
+      await invalidateSkillQueries(queryClient)
+    },
+  })
+}
+
+export function useDeleteSkillMutation() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: (id: string) => api('DELETE', `/skills/${id}`),
+    onSuccess: async () => {
+      await invalidateSkillQueries(queryClient)
+    },
+  })
+}
+
+export function useGenerateSkillSuggestionMutation() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: (sessionId: string) => api<SkillSuggestion>('POST', '/skill-suggestions', { sessionId }),
+    onSuccess: async () => {
+      await queryClient.invalidateQueries({ queryKey: skillSuggestionQueryKeys.all })
+    },
+  })
+}
+
+export function useApproveSkillSuggestionMutation() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: (id: string) => api('POST', `/skill-suggestions/${id}/approve`),
+    onSuccess: async () => {
+      await Promise.all([
+        queryClient.invalidateQueries({ queryKey: skillSuggestionQueryKeys.all }),
+        invalidateSkillQueries(queryClient),
+      ])
+    },
+  })
+}
+
+export function useRejectSkillSuggestionMutation() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: (id: string) => api('POST', `/skill-suggestions/${id}/reject`),
+    onSuccess: async () => {
+      await queryClient.invalidateQueries({ queryKey: skillSuggestionQueryKeys.all })
+    },
+  })
+}
+
+export function useClawHubSearchMutation() {
+  return useMutation({
+    mutationFn: ({
+      query,
+      page,
+      limit,
+      cursor,
+    }: {
+      query: string
+      page: number
+      limit: number
+      cursor?: string | null
+    }) => {
+      const params = new URLSearchParams({
+        q: query,
+        page: String(page),
+        limit: String(limit),
+      })
+      if (cursor) params.set('cursor', cursor)
+      return api<ClawHubSearchResponse>('GET', `/clawhub/search?${params.toString()}`)
+    },
+  })
+}
+
+export function useClawHubPreviewMutation() {
+  return useMutation({
+    mutationFn: (payload: {
+      name: string
+      description?: string
+      author?: string
+      tags?: string[]
+      url: string
+    }) => api<ClawHubPreview>('POST', '/clawhub/preview', payload),
+  })
+}
+
+export function useInstallClawHubSkillMutation() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: (payload: {
+      name: string
+      description?: string
+      url: string
+      author?: string
+      tags?: string[]
+      content?: string
+    }) => api('POST', '/clawhub/install', payload),
+    onSuccess: async () => {
+      await invalidateSkillQueries(queryClient)
+    },
+  })
+}

package/src/features/tasks/queries.ts

@@ -0,0 +1,189 @@
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
+import { api } from '@/lib/app/api-client'
+import {
+  bulkUpdateTasks,
+  createTask,
+  fetchTasks,
+  importGitHubIssues,
+  updateTask,
+  type GitHubIssueImportRequest,
+  type GitHubIssueImportResult,
+} from '@/lib/tasks'
+import type { BoardTask, BoardTaskStatus, TaskComment } from '@/types'
+
+export type {
+  GitHubIssueImportRequest,
+  GitHubIssueImportResult,
+} from '@/lib/tasks'
+
+type TasksRecord = Record<string, BoardTask>
+type QueryOptions = {
+  enabled?: boolean
+  includeArchived?: boolean
+}
+type TasksSnapshot = Array<[readonly unknown[], TasksRecord | undefined]>
+
+export const taskQueryKeys = {
+  all: ['tasks'] as const,
+  lists: () => ['tasks', 'list'] as const,
+  list: (params: { includeArchived: boolean }) => ['tasks', 'list', params] as const,
+}
+
+function includeArchivedFromKey(key: readonly unknown[]): boolean {
+  const params = key[2]
+  return typeof params === 'object' && params !== null && (params as { includeArchived?: boolean }).includeArchived === true
+}
+
+function captureTaskSnapshots(queryClient: ReturnType<typeof useQueryClient>): TasksSnapshot {
+  return queryClient.getQueriesData<TasksRecord>({ queryKey: taskQueryKeys.lists() }) as TasksSnapshot
+}
+
+function restoreTaskSnapshots(
+  queryClient: ReturnType<typeof useQueryClient>,
+  snapshots: TasksSnapshot | undefined,
+): void {
+  if (!snapshots) return
+  for (const [key, data] of snapshots) {
+    queryClient.setQueryData(key, data)
+  }
+}
+
+function applyTaskListPatch(
+  current: TasksRecord | undefined,
+  taskId: string,
+  nextTask: BoardTask | null,
+  includeArchived: boolean,
+): TasksRecord | undefined {
+  if (!current) return current
+  const next = { ...current }
+  if (!nextTask || (!includeArchived && nextTask.status === 'archived')) {
+    delete next[taskId]
+    return next
+  }
+  next[taskId] = nextTask
+  return next
+}
+
+function patchTaskCaches(
+  queryClient: ReturnType<typeof useQueryClient>,
+  updater: (current: TasksRecord | undefined, includeArchived: boolean) => TasksRecord | undefined,
+): TasksSnapshot {
+  const snapshots = captureTaskSnapshots(queryClient)
+  for (const [key] of snapshots) {
+    queryClient.setQueryData<TasksRecord>(key, (current) => updater(current, includeArchivedFromKey(key)))
+  }
+  return snapshots
+}
+
+export function useTasksQuery(options: QueryOptions = {}) {
+  const includeArchived = options.includeArchived ?? false
+  return useQuery<TasksRecord>({
+    queryKey: taskQueryKeys.list({ includeArchived }),
+    queryFn: () => fetchTasks(includeArchived),
+    enabled: options.enabled,
+    staleTime: 10_000,
+  })
+}
+
+export function useCreateTaskMutation() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: createTask,
+    onSuccess: async () => {
+      await queryClient.invalidateQueries({ queryKey: taskQueryKeys.all })
+    },
+  })
+}
+
+export function useUpdateTaskMutation() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: ({ id, patch }: { id: string; patch: Partial<BoardTask> }) => updateTask(id, patch),
+    onMutate: async ({ id, patch }) => {
+      await queryClient.cancelQueries({ queryKey: taskQueryKeys.lists() })
+      const snapshots = patchTaskCaches(queryClient, (current, includeArchived) => {
+        const existing = current?.[id]
+        if (!existing) return current
+        const nextTask = { ...existing, ...patch, updatedAt: Date.now() }
+        return applyTaskListPatch(current, id, nextTask, includeArchived)
+      })
+      return { snapshots }
+    },
+    onError: (_error, _variables, context) => {
+      restoreTaskSnapshots(queryClient, context?.snapshots)
+    },
+    onSettled: async () => {
+      await queryClient.invalidateQueries({ queryKey: taskQueryKeys.all })
+    },
+  })
+}
+
+export function useBulkUpdateTasksMutation() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: ({ ids, patch }: { ids: string[]; patch: { status?: BoardTaskStatus; agentId?: string; projectId?: string | null } }) =>
+      bulkUpdateTasks(ids, patch),
+    onMutate: async ({ ids, patch }) => {
+      await queryClient.cancelQueries({ queryKey: taskQueryKeys.lists() })
+      const snapshots = patchTaskCaches(queryClient, (current, includeArchived) => {
+        if (!current) return current
+        const next = { ...current }
+        for (const id of ids) {
+          const existing = next[id]
+          if (!existing) continue
+          const updated: BoardTask = {
+            ...existing,
+            ...patch,
+            agentId: patch.agentId ?? existing.agentId,
+            projectId: patch.projectId === undefined ? existing.projectId : patch.projectId ?? undefined,
+            updatedAt: Date.now(),
+          }
+          if (!includeArchived && updated.status === 'archived') {
+            delete next[id]
+            continue
+          }
+          next[id] = updated
+        }
+        return next
+      })
+      return { snapshots }
+    },
+    onError: (_error, _variables, context) => {
+      restoreTaskSnapshots(queryClient, context?.snapshots)
+    },
+    onSettled: async () => {
+      await queryClient.invalidateQueries({ queryKey: taskQueryKeys.all })
+    },
+  })
+}
+
+export function useClearDoneTasksMutation() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: () => api('DELETE', '/tasks?filter=done'),
+    onSuccess: async () => {
+      await queryClient.invalidateQueries({ queryKey: taskQueryKeys.all })
+    },
+  })
+}
+
+export function useImportGitHubIssuesMutation() {
+  const queryClient = useQueryClient()
+  return useMutation<GitHubIssueImportResult, Error, GitHubIssueImportRequest>({
+    mutationFn: importGitHubIssues,
+    onSuccess: async () => {
+      await queryClient.invalidateQueries({ queryKey: taskQueryKeys.all })
+    },
+  })
+}
+
+export function useAppendTaskCommentMutation() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: ({ id, comment }: { id: string; comment: TaskComment }) =>
+      updateTask(id, { appendComment: comment } as Partial<BoardTask> & { appendComment: TaskComment }),
+    onSettled: async () => {
+      await queryClient.invalidateQueries({ queryKey: taskQueryKeys.all })
+    },
+  })
+}

package/src/hooks/use-ws.ts

@@ -2,14 +2,15 @@
 
 import { useEffect, useRef } from 'react'
 import { subscribeWs, unsubscribeWs, isWsConnected, onWsStateChange, offWsStateChange } from '@/lib/ws-client'
+import { hmrSingleton } from '@/lib/shared-utils'
 import { usePageActive } from './use-page-active'
 
 /** Shared fallback intervals keyed by topic — multiple useWs instances share one interval. */
-const sharedFallbacks = new Map<string, {
+const sharedFallbacks = hmrSingleton('useWs_sharedFallbacks', () => new Map<string, {
   interval: ReturnType<typeof setInterval> | null
   handlers: Set<() => void>
   ms: number
-}>()
+}>())
 
 function runAllHandlers(topic: string): void {
   const entry = sharedFallbacks.get(topic)

package/src/lib/app/api-client.ts

@@ -1,12 +1,12 @@
 import { fetchWithTimeout, isAbortError, isTimeoutError } from '@/lib/fetch-timeout'
 import { safeStorageGet, safeStorageSet, safeStorageRemove } from './safe-storage'
-import { sleep } from '@/lib/shared-utils'
+import { sleep, hmrSingleton } from '@/lib/shared-utils'
 
 const ACCESS_KEY_STORAGE = 'sc_access_key'
 const DEFAULT_API_TIMEOUT_MS = 12_000
 const DEFAULT_GET_RETRIES = 2
 const RETRY_DELAY_BASE_MS = 300
-const inflightGetRequests = new Map<string, Promise<unknown>>()
+const inflightGetRequests = hmrSingleton('apiClient_inflightGetRequests', () => new Map<string, Promise<unknown>>())
 
 export function getStoredAccessKey(): string {
   return safeStorageGet(ACCESS_KEY_STORAGE) || ''

package/src/lib/providers/index.test.ts

@@ -76,3 +76,111 @@ test('builtin provider override records do not surface as custom providers', ()
 
   assert.equal(output.openAiCount, 1)
 })
+
+test('custom provider resolution includes defaultEndpoint and optionalApiKey', () => {
+  const output = runWithTempDataDir<{
+    defaultEndpoint: string | null
+    optionalApiKey: boolean | null
+    requiresApiKey: boolean | null
+  }>(`
+    const storageModule = await import('@/lib/server/storage')
+    const storage = storageModule.default || storageModule
+    storage.saveProviderConfigs({
+      'custom-llama-server': {
+        id: 'custom-llama-server',
+        name: 'llama-server',
+        type: 'custom',
+        baseUrl: 'http://127.0.0.1:8080/v1',
+        models: ['my-model'],
+        requiresApiKey: false,
+        credentialId: null,
+        isEnabled: true,
+        createdAt: 1,
+        updatedAt: 1,
+      },
+    })
+
+    const providersModule = await import('@/lib/providers/index')
+    const providers = providersModule.default || providersModule
+    const resolved = providers.getProvider('custom-llama-server')
+
+    console.log(JSON.stringify({
+      defaultEndpoint: resolved?.defaultEndpoint ?? null,
+      optionalApiKey: resolved?.optionalApiKey ?? null,
+      requiresApiKey: resolved?.requiresApiKey ?? null,
+    }))
+  `)
+
+  assert.equal(output.defaultEndpoint, 'http://127.0.0.1:8080/v1')
+  assert.equal(output.optionalApiKey, true)
+  assert.equal(output.requiresApiKey, false)
+})
+
+test('custom provider with uuid-style ID resolves correctly', () => {
+  const output = runWithTempDataDir<{
+    resolvedName: string | null
+    hasHandler: boolean
+  }>(`
+    const storageModule = await import('@/lib/server/storage')
+    const storage = storageModule.default || storageModule
+    storage.saveProviderConfigs({
+      'custom-d20b934e': {
+        id: 'custom-d20b934e',
+        name: 'My llama-server',
+        type: 'custom',
+        baseUrl: 'http://127.0.0.1:8080/v1',
+        models: ['llama-3.1-8b'],
+        requiresApiKey: false,
+        credentialId: null,
+        isEnabled: true,
+        createdAt: 1,
+        updatedAt: 1,
+      },
+    })
+
+    const providersModule = await import('@/lib/providers/index')
+    const providers = providersModule.default || providersModule
+    const resolved = providers.getProvider('custom-d20b934e')
+
+    console.log(JSON.stringify({
+      resolvedName: resolved?.name ?? null,
+      hasHandler: typeof resolved?.handler?.streamChat === 'function',
+    }))
+  `)
+
+  assert.equal(output.resolvedName, 'My llama-server')
+  assert.equal(output.hasHandler, true)
+})
+
+test('disabled custom providers are not resolved by getProvider', () => {
+  const output = runWithTempDataDir<{
+    resolved: boolean
+  }>(`
+    const storageModule = await import('@/lib/server/storage')
+    const storage = storageModule.default || storageModule
+    storage.saveProviderConfigs({
+      'custom-disabled': {
+        id: 'custom-disabled',
+        name: 'Disabled Provider',
+        type: 'custom',
+        baseUrl: 'http://127.0.0.1:8080/v1',
+        models: ['test'],
+        requiresApiKey: false,
+        credentialId: null,
+        isEnabled: false,
+        createdAt: 1,
+        updatedAt: 1,
+      },
+    })
+
+    const providersModule = await import('@/lib/providers/index')
+    const providers = providersModule.default || providersModule
+    const resolved = providers.getProvider('custom-disabled')
+
+    console.log(JSON.stringify({
+      resolved: resolved !== null,
+    }))
+  `)
+
+  assert.equal(output.resolved, false)
+})

package/src/lib/providers/index.ts

@@ -286,7 +286,8 @@ function getCustomProviders(): Record<string, CustomProviderConfig> {
     return Object.fromEntries(
       Object.entries(configs).filter(([, config]) => config?.type === 'custom'),
     )
-  } catch {
+  } catch (err) {
+    log.warn(TAG, 'Failed to load custom providers from storage', errorMessage(err))
     return {}
   }
 }
@@ -325,6 +326,7 @@ export function getProviderList(): ProviderInfo[] {
       defaultModels: c.models,
       supportsModelDiscovery: false,
       requiresApiKey: c.requiresApiKey,
+      optionalApiKey: !c.requiresApiKey,
       requiresEndpoint: false as boolean,
       defaultEndpoint: c.baseUrl,
     }))
@@ -348,26 +350,47 @@ export function getProviderList(): ProviderInfo[] {
   return [...builtins, ...customs, ...extensionProviders]
 }
 
+function buildCustomProviderConfig(custom: CustomProviderConfig): BuiltinProviderConfig {
+  return {
+    id: custom.id as ProviderId,
+    name: custom.name,
+    models: custom.models,
+    requiresApiKey: custom.requiresApiKey,
+    optionalApiKey: !custom.requiresApiKey,
+    requiresEndpoint: false,
+    defaultEndpoint: custom.baseUrl,
+    handler: {
+      streamChat: async (opts) => {
+        const patchedSession = { ...opts.session, apiEndpoint: custom.baseUrl }
+        const { streamOpenAiChat } = await import('./openai')
+        return streamOpenAiChat({ ...opts, session: patchedSession })
+      },
+    },
+  }
+}
+
 export function getProvider(id: string): BuiltinProviderConfig | null {
   if (PROVIDERS[id]) return PROVIDERS[id]
-  
+
   // Check custom providers
   const customs = getCustomProviders()
   const custom = customs[id]
   if (custom?.isEnabled) {
-    return {
-      id: custom.id as ProviderId,
-      name: custom.name,
-      models: custom.models,
-      requiresApiKey: custom.requiresApiKey,
-      requiresEndpoint: false,
-      handler: {
-        streamChat: async (opts) => {
-          const patchedSession = { ...opts.session, apiEndpoint: custom.baseUrl }
-          const { streamOpenAiChat } = await import('./openai')
-          return streamOpenAiChat({ ...opts, session: patchedSession })
-        },
-      },
+    return buildCustomProviderConfig(custom)
+  }
+
+  // Fallback: direct single-item DB lookup for custom-* providers
+  if (id.startsWith('custom-') && !custom) {
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      const { loadStoredItem } = require('@/lib/server/storage') as typeof import('@/lib/server/storage')
+      const directConfig = loadStoredItem('provider_configs', id) as CustomProviderConfig | null
+      if (directConfig?.type === 'custom' && directConfig.isEnabled) {
+        log.info(TAG, `Resolved custom provider '${id}' via direct DB lookup (batch load missed it)`)
+        return buildCustomProviderConfig(directConfig)
+      }
+    } catch (err) {
+      log.warn(TAG, `Direct DB lookup failed for provider '${id}'`, errorMessage(err))
     }
   }
 

package/src/lib/query/client.ts

@@ -0,0 +1,17 @@
+import { QueryClient } from '@tanstack/react-query'
+
+export function createAppQueryClient(): QueryClient {
+  return new QueryClient({
+    defaultOptions: {
+      queries: {
+        staleTime: 15_000,
+        gcTime: 5 * 60_000,
+        retry: 0,
+        refetchOnWindowFocus: false,
+      },
+      mutations: {
+        retry: 0,
+      },
+    },
+  })
+}

package/src/lib/server/agents/agent-runtime-config.ts

@@ -7,7 +7,7 @@ import type {
 } from '@/types'
 import { deriveOpenClawWsUrl, normalizeProviderEndpoint } from '@/lib/openclaw/openclaw-endpoint'
 import { resolveProviderApiEndpoint, resolveProviderCredentialId } from '@/lib/server/provider-endpoint'
-import { loadGatewayProfiles } from '@/lib/server/storage'
+import { loadGatewayProfiles } from '@/lib/server/gateways/gateway-profile-repository'
 import { isProviderCoolingDown } from '@/lib/server/provider-health'
 
 const DEFAULT_OPENCLAW_ENDPOINT = 'http://localhost:18789/v1'