@swarmclawai/swarmclaw 1.2.3 → 1.2.5

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/agent-provider-options.test.ts

@@ -0,0 +1,152 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import type { Credentials, ProviderConfig, ProviderInfo } from '@/types'
+import { buildAgentSelectableProviders, resolveAgentSelectableProviderCredentials } from './agent-provider-options'
+
+test('buildAgentSelectableProviders includes enabled custom providers missing from the provider list', () => {
+  const providers: ProviderInfo[] = [
+    {
+      id: 'openai',
+      name: 'OpenAI',
+      models: ['gpt-5'],
+      defaultModels: ['gpt-5'],
+      supportsModelDiscovery: true,
+      requiresApiKey: true,
+      requiresEndpoint: false,
+    },
+  ]
+  const providerConfigs: ProviderConfig[] = [
+    {
+      id: 'custom-llama',
+      name: 'Llama.cpp',
+      type: 'custom',
+      baseUrl: 'http://localhost:8080/v1',
+      models: ['llama-3.1-70b'],
+      requiresApiKey: false,
+      credentialId: null,
+      isEnabled: true,
+      createdAt: 1,
+      updatedAt: 1,
+    },
+  ]
+
+  const result = buildAgentSelectableProviders(providers, providerConfigs)
+  assert.equal(result.some((provider) => provider.id === 'custom-llama'), true)
+  assert.equal(result.find((provider) => provider.id === 'custom-llama')?.name, 'Llama.cpp')
+  assert.equal(result.find((provider) => provider.id === 'custom-llama')?.supportsModelDiscovery, false)
+})
+
+test('buildAgentSelectableProviders prefers custom provider config metadata when ids overlap', () => {
+  const providers: ProviderInfo[] = [
+    {
+      id: 'custom-llama',
+      name: 'Stale Custom',
+      models: ['old-model'],
+      defaultModels: ['old-model'],
+      supportsModelDiscovery: false,
+      requiresApiKey: true,
+      requiresEndpoint: false,
+      defaultEndpoint: 'http://old.example/v1',
+    },
+  ]
+  const providerConfigs: ProviderConfig[] = [
+    {
+      id: 'custom-llama',
+      name: 'Fresh Custom',
+      type: 'custom',
+      baseUrl: 'http://localhost:8080/v1',
+      models: ['llama-3.1-70b'],
+      requiresApiKey: false,
+      credentialId: 'cred_custom',
+      isEnabled: true,
+      createdAt: 1,
+      updatedAt: 2,
+    },
+  ]
+
+  const result = buildAgentSelectableProviders(providers, providerConfigs)
+  assert.deepEqual(result, [
+    {
+      id: 'custom-llama',
+      name: 'Fresh Custom',
+      models: ['llama-3.1-70b'],
+      defaultModels: ['llama-3.1-70b'],
+      supportsModelDiscovery: false,
+      requiresApiKey: false,
+      optionalApiKey: false,
+      requiresEndpoint: true,
+      defaultEndpoint: 'http://localhost:8080/v1',
+      credentialId: 'cred_custom',
+      type: 'custom',
+    },
+  ])
+})
+
+test('buildAgentSelectableProviders hides built-in providers disabled in provider configs', () => {
+  const providers: ProviderInfo[] = [
+    {
+      id: 'openai',
+      name: 'OpenAI',
+      models: ['gpt-5'],
+      defaultModels: ['gpt-5'],
+      supportsModelDiscovery: true,
+      requiresApiKey: true,
+      requiresEndpoint: false,
+    },
+    {
+      id: 'anthropic',
+      name: 'Anthropic',
+      models: ['claude-sonnet-4-6'],
+      defaultModels: ['claude-sonnet-4-6'],
+      supportsModelDiscovery: true,
+      requiresApiKey: true,
+      requiresEndpoint: false,
+    },
+  ]
+  const providerConfigs: ProviderConfig[] = [
+    {
+      id: 'openai',
+      name: 'OpenAI',
+      type: 'builtin',
+      baseUrl: '',
+      models: [],
+      requiresApiKey: true,
+      credentialId: null,
+      isEnabled: false,
+      createdAt: 1,
+      updatedAt: 1,
+    },
+  ]
+
+  const result = buildAgentSelectableProviders(providers, providerConfigs)
+  assert.deepEqual(result.map((provider) => provider.id), ['anthropic'])
+})
+
+test('resolveAgentSelectableProviderCredentials includes linked provider-config credentials', () => {
+  const credentials: Credentials = {
+    cred_custom: {
+      id: 'cred_custom',
+      provider: 'OpenRouter',
+      name: 'OpenRouter key',
+      createdAt: 1,
+    },
+  }
+  const providerConfigs: ProviderConfig[] = [
+    {
+      id: 'custom-openrouter',
+      name: 'OpenRouter Custom',
+      type: 'custom',
+      baseUrl: 'https://openrouter.ai/api/v1',
+      models: ['openai/gpt-4.1'],
+      requiresApiKey: true,
+      credentialId: 'cred_custom',
+      isEnabled: true,
+      createdAt: 1,
+      updatedAt: 1,
+    },
+  ]
+
+  const result = resolveAgentSelectableProviderCredentials('custom-openrouter', credentials, providerConfigs)
+  assert.deepEqual(result.map((credential) => credential.id), ['cred_custom'])
+})

package/src/lib/agent-provider-options.ts

@@ -0,0 +1,84 @@
+import type { Credential, Credentials, ProviderConfig, ProviderInfo } from '@/types'
+
+export interface AgentSelectableProvider {
+  id: string
+  name: string
+  models: string[]
+  defaultModels?: string[]
+  supportsModelDiscovery?: boolean
+  requiresApiKey: boolean
+  optionalApiKey?: boolean
+  requiresEndpoint: boolean
+  defaultEndpoint?: string
+  credentialId?: string | null
+  type: 'builtin' | 'custom'
+}
+
+function buildCustomProviderOption(config: ProviderConfig): AgentSelectableProvider {
+  return {
+    id: config.id,
+    name: config.name || 'Custom Provider',
+    models: Array.isArray(config.models) ? config.models : [],
+    defaultModels: Array.isArray(config.models) ? config.models : [],
+    supportsModelDiscovery: false,
+    requiresApiKey: config.requiresApiKey,
+    optionalApiKey: false,
+    requiresEndpoint: Boolean(config.baseUrl),
+    defaultEndpoint: config.baseUrl || undefined,
+    credentialId: config.credentialId ?? null,
+    type: 'custom',
+  }
+}
+
+export function buildAgentSelectableProviders(
+  providers: ProviderInfo[],
+  providerConfigs: ProviderConfig[],
+): AgentSelectableProvider[] {
+  const disabledBuiltinIds = new Set(
+    providerConfigs
+      .filter((config) => config.type === 'builtin' && config.isEnabled === false)
+      .map((config) => config.id),
+  )
+
+  const merged: AgentSelectableProvider[] = providers
+    .filter((provider) => !disabledBuiltinIds.has(String(provider.id)))
+    .map((provider) => ({
+    ...provider,
+    credentialId: null,
+    type: 'builtin' as const,
+    }))
+  const indexById = new Map(merged.map((provider, index) => [provider.id, index]))
+
+  for (const config of providerConfigs) {
+    if (config.type !== 'custom' || config.isEnabled === false) continue
+    const customProvider = buildCustomProviderOption(config)
+    const existingIndex = indexById.get(config.id)
+    if (existingIndex == null) {
+      indexById.set(config.id, merged.length)
+      merged.push(customProvider)
+      continue
+    }
+    merged[existingIndex] = customProvider
+  }
+
+  return merged
+}
+
+export function resolveAgentSelectableProviderCredentials(
+  providerId: string,
+  credentials: Credentials,
+  providerConfigs: ProviderConfig[],
+): Credential[] {
+  const matches = Object.values(credentials).filter((credential) => credential.provider === providerId)
+  const config = providerConfigs.find((candidate) => (
+    candidate.type === 'custom'
+    && candidate.id === providerId
+    && candidate.isEnabled !== false
+  ))
+  if (!config?.credentialId) return matches
+
+  const linkedCredential = credentials[config.credentialId]
+  if (!linkedCredential) return matches
+  if (matches.some((credential) => credential.id === linkedCredential.id)) return matches
+  return [...matches, linkedCredential]
+}

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) || ''