@swarmclawai/swarmclaw 1.2.4 → 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/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/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'