@swarmclawai/swarmclaw 1.2.4 → 1.2.5

package/src/features/gateways/queries.ts

@@ -0,0 +1,274 @@
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
+import { api } from '@/lib/app/api-client'
+import { credentialQueryKeys } from '@/features/credentials/queries'
+import type {
+  GatewayProfile,
+  OpenClawDevicePairRequest,
+  OpenClawNode,
+  OpenClawNodePairRequest,
+  OpenClawPairedDevice,
+} from '@/types'
+
+type QueryOptions = {
+  enabled?: boolean
+}
+
+export interface GatewayDiscoveryResult {
+  host: string
+  port: number
+  healthy: boolean
+  models?: string[]
+  error?: string
+}
+
+export interface GatewayRpcResponse<T> {
+  ok?: boolean
+  result?: T
+  error?: string
+}
+
+interface NodeListResult {
+  nodes?: OpenClawNode[]
+}
+
+interface PairingListResult<T> {
+  pending?: T[]
+  paired?: OpenClawPairedDevice[]
+}
+
+interface SaveGatewayProfileInput {
+  id?: string | null
+  payload: Record<string, unknown>
+}
+
+interface VerifyOpenClawDeployInput {
+  endpoint: string
+  token?: string
+}
+
+export interface VerifyOpenClawDeployResult {
+  ok: boolean
+  verify?: {
+    ok: boolean
+    message?: string
+    error?: string
+    hint?: string
+    models?: string[]
+  }
+}
+
+export interface RefreshGatewayTopologyResult {
+  nodes: OpenClawNode[]
+  nodePairings: OpenClawNodePairRequest[]
+  devicePairings: OpenClawDevicePairRequest[]
+  pairedDevices: OpenClawPairedDevice[]
+}
+
+async function invalidateGatewayQueries(queryClient: ReturnType<typeof useQueryClient>) {
+  await queryClient.invalidateQueries({ queryKey: gatewayQueryKeys.all })
+}
+
+export const gatewayQueryKeys = {
+  all: ['gateways'] as const,
+  profiles: () => ['gateways', 'profiles'] as const,
+}
+
+export function useGatewayProfilesQuery(options: QueryOptions = {}) {
+  return useQuery<GatewayProfile[]>({
+    queryKey: gatewayQueryKeys.profiles(),
+    queryFn: () => api<GatewayProfile[]>('GET', '/gateways'),
+    enabled: options.enabled,
+    staleTime: 20_000,
+  })
+}
+
+export function useSaveGatewayProfileMutation() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: ({ id, payload }: SaveGatewayProfileInput) =>
+      id ? api('PUT', `/gateways/${id}`, payload) : api('POST', '/gateways', payload),
+    onSuccess: async () => {
+      await Promise.all([
+        invalidateGatewayQueries(queryClient),
+        queryClient.invalidateQueries({ queryKey: credentialQueryKeys.all }),
+      ])
+    },
+  })
+}
+
+export function useDeleteGatewayProfileMutation() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: (id: string) => api('DELETE', `/gateways/${id}`),
+    onSuccess: async () => {
+      await invalidateGatewayQueries(queryClient)
+    },
+  })
+}
+
+export function useCloneGatewayProfileMutation() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: (payload: Record<string, unknown>) => api('POST', '/gateways', payload),
+    onSuccess: async () => {
+      await invalidateGatewayQueries(queryClient)
+    },
+  })
+}
+
+export function useGatewayHealthCheckMutation() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: (id: string) => api('GET', `/gateways/${id}/health`),
+    onSuccess: async () => {
+      await invalidateGatewayQueries(queryClient)
+    },
+  })
+}
+
+export function useVerifyOpenClawDeployMutation() {
+  return useMutation<VerifyOpenClawDeployResult, Error, VerifyOpenClawDeployInput>({
+    mutationFn: ({ endpoint, token }) =>
+      api<VerifyOpenClawDeployResult>('POST', '/openclaw/deploy', {
+        action: 'verify',
+        endpoint,
+        token: token?.trim() || undefined,
+      }),
+  })
+}
+
+export function useCheckOpenClawGatewayMutation() {
+  return useMutation({
+    mutationFn: async ({
+      endpoint,
+      credentialId,
+      token,
+    }: {
+      endpoint: string
+      credentialId?: string | null
+      token?: string | null
+    }) => {
+      const params = new URLSearchParams()
+      params.set('endpoint', endpoint.trim() || 'http://localhost:18789')
+      if (credentialId) params.set('credentialId', credentialId)
+      if (token?.trim()) params.set('token', token.trim())
+      return api<{ ok: boolean; models: string[]; message?: string; error?: string; hint?: string }>(
+        'GET',
+        `/providers/openclaw/health?${params.toString()}`,
+      )
+    },
+  })
+}
+
+export function useDiscoverOpenClawGatewaysMutation() {
+  return useMutation({
+    mutationFn: () => api<{ gateways: GatewayDiscoveryResult[] }>('GET', '/openclaw/discover'),
+  })
+}
+
+export function useRefreshGatewayTopologyMutation() {
+  const queryClient = useQueryClient()
+  return useMutation<RefreshGatewayTopologyResult, Error, string>({
+    mutationFn: async (profileId) => {
+      const [nodesRes, nodePairRes, devicePairRes] = await Promise.all([
+        api<GatewayRpcResponse<NodeListResult>>('POST', '/openclaw/gateway', {
+          method: 'node.list',
+          params: { profileId },
+        }),
+        api<GatewayRpcResponse<PairingListResult<OpenClawNodePairRequest>>>('POST', '/openclaw/gateway', {
+          method: 'node.pair.list',
+          params: { profileId },
+        }),
+        api<GatewayRpcResponse<PairingListResult<OpenClawDevicePairRequest>>>('POST', '/openclaw/gateway', {
+          method: 'device.pair.list',
+          params: { profileId },
+        }),
+      ])
+
+      if (nodesRes.error) throw new Error(nodesRes.error)
+      if (nodePairRes.error) throw new Error(nodePairRes.error)
+      if (devicePairRes.error) throw new Error(devicePairRes.error)
+
+      const nodes = Array.isArray(nodesRes.result?.nodes) ? nodesRes.result.nodes : []
+      const nodePairings = Array.isArray(nodePairRes.result?.pending) ? nodePairRes.result.pending : []
+      const devicePairings = Array.isArray(devicePairRes.result?.pending) ? devicePairRes.result.pending : []
+      const pairedDevices = Array.isArray(devicePairRes.result?.paired) ? devicePairRes.result.paired : []
+      const stats = {
+        nodeCount: nodes.length,
+        connectedNodeCount: nodes.filter((node) => node.connected).length,
+        pendingNodePairings: nodePairings.length,
+        pairedDeviceCount: pairedDevices.length,
+        pendingDevicePairings: devicePairings.length,
+      }
+
+      void api('PUT', `/gateways/${profileId}`, { stats }).catch(() => {})
+
+      return {
+        nodes,
+        nodePairings,
+        devicePairings,
+        pairedDevices,
+      }
+    },
+    onSuccess: async () => {
+      await invalidateGatewayQueries(queryClient)
+    },
+  })
+}
+
+export function useGatewayPairingDecisionMutation() {
+  return useMutation({
+    mutationFn: ({
+      profileId,
+      kind,
+      requestId,
+      decision,
+    }: {
+      profileId: string
+      kind: 'node' | 'device'
+      requestId: string
+      decision: 'approve' | 'reject'
+    }) =>
+      api<GatewayRpcResponse<unknown>>('POST', '/openclaw/gateway', {
+        method: kind === 'node'
+          ? (decision === 'approve' ? 'node.pair.approve' : 'node.pair.reject')
+          : (decision === 'approve' ? 'device.pair.approve' : 'device.pair.reject'),
+        params: { profileId, requestId },
+      }),
+  })
+}
+
+export function useGatewayRemoveDeviceMutation() {
+  return useMutation({
+    mutationFn: ({ profileId, deviceId }: { profileId: string; deviceId: string }) =>
+      api<GatewayRpcResponse<unknown>>('POST', '/openclaw/gateway', {
+        method: 'device.pair.remove',
+        params: { profileId, deviceId },
+      }),
+  })
+}
+
+export function useGatewayInvokeNodeMutation() {
+  return useMutation({
+    mutationFn: ({
+      profileId,
+      nodeId,
+      command,
+      params,
+    }: {
+      profileId: string
+      nodeId: string
+      command: string
+      params: Record<string, unknown>
+    }) =>
+      api<GatewayRpcResponse<unknown>>('POST', '/openclaw/gateway', {
+        method: 'node.invoke',
+        params: {
+          profileId,
+          nodeId,
+          command,
+          params,
+        },
+      }),
+  })
+}

package/src/features/missions/queries.ts

@@ -0,0 +1,23 @@
+import { useQuery } from '@tanstack/react-query'
+import { api } from '@/lib/app/api-client'
+import type { Mission } from '@/types'
+
+type MissionListOptions = {
+  enabled?: boolean
+  limit?: number
+}
+
+export const missionQueryKeys = {
+  all: ['missions'] as const,
+  list: (limit: number) => ['missions', 'list', { limit }] as const,
+}
+
+export function useMissionsQuery(options: MissionListOptions = {}) {
+  const limit = options.limit ?? 80
+  return useQuery<Mission[]>({
+    queryKey: missionQueryKeys.list(limit),
+    queryFn: () => api<Mission[]>('GET', `/missions?limit=${limit}`),
+    enabled: options.enabled,
+    staleTime: 30_000,
+  })
+}

package/src/features/projects/queries.ts

@@ -0,0 +1,20 @@
+import { useQuery } from '@tanstack/react-query'
+import { fetchProjects } from '@/lib/projects'
+import type { Project } from '@/types'
+
+type QueryOptions = {
+  enabled?: boolean
+}
+
+export const projectQueryKeys = {
+  all: ['projects'] as const,
+}
+
+export function useProjectsQuery(options: QueryOptions = {}) {
+  return useQuery<Record<string, Project>>({
+    queryKey: projectQueryKeys.all,
+    queryFn: fetchProjects,
+    enabled: options.enabled,
+    staleTime: 60_000,
+  })
+}

package/src/features/protocols/queries.ts

@@ -0,0 +1,149 @@
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
+import { api } from '@/lib/app/api-client'
+import type { ProtocolRunDetail } from '@/lib/server/protocols/protocol-types'
+import type { ProtocolRun, ProtocolStepDefinition, ProtocolTemplate } from '@/types'
+
+export type ProtocolRunListParams = {
+  limit?: number
+  missionId?: string | null
+  taskId?: string | null
+  sessionId?: string | null
+  parentChatroomId?: string | null
+}
+
+export interface ProtocolRunCreatePayload {
+  title: string
+  templateId?: string | null
+  participantAgentIds: string[]
+  facilitatorAgentId?: string | null
+  sessionId?: string | null
+  parentChatroomId?: string | null
+  missionId?: string | null
+  taskId?: string | null
+  autoStart?: boolean
+  createTranscript?: boolean
+  config?: Record<string, unknown> | null
+}
+
+export interface ProtocolTemplatePayload {
+  name: string
+  description: string
+  tags: string[]
+  recommendedOutputs: string[]
+  singleAgentAllowed: boolean
+  steps: ProtocolStepDefinition[]
+  entryStepId?: string | null
+}
+
+export type ProtocolRunActionPayload =
+  | { action: 'start' | 'pause' | 'resume' | 'retry_phase' | 'skip_phase' | 'cancel' | 'archive' }
+  | { action: 'inject_context'; context: string }
+
+type QueryOptions = {
+  enabled?: boolean
+}
+
+type ProtocolRunListQueryOptions = ProtocolRunListParams & QueryOptions
+
+function normalizeRunListParams(params: ProtocolRunListParams = {}) {
+  return {
+    limit: params.limit ?? 120,
+    missionId: params.missionId ?? null,
+    taskId: params.taskId ?? null,
+    sessionId: params.sessionId ?? null,
+    parentChatroomId: params.parentChatroomId ?? null,
+  }
+}
+
+function buildRunListQueryString(params: ReturnType<typeof normalizeRunListParams>): string {
+  const query = new URLSearchParams()
+  query.set('limit', String(params.limit))
+  if (params.missionId) query.set('missionId', params.missionId)
+  if (params.taskId) query.set('taskId', params.taskId)
+  if (params.sessionId) query.set('sessionId', params.sessionId)
+  if (params.parentChatroomId) query.set('parentChatroomId', params.parentChatroomId)
+  return query.toString()
+}
+
+export const protocolQueryKeys = {
+  all: ['protocols'] as const,
+  templates: () => ['protocols', 'templates'] as const,
+  runs: () => ['protocols', 'runs'] as const,
+  runList: (params: ReturnType<typeof normalizeRunListParams>) => ['protocols', 'runs', params] as const,
+  runDetail: (runId: string | null) => ['protocols', 'run', runId] as const,
+}
+
+export function useProtocolTemplatesQuery(options: QueryOptions = {}) {
+  return useQuery<ProtocolTemplate[]>({
+    queryKey: protocolQueryKeys.templates(),
+    queryFn: () => api<ProtocolTemplate[]>('GET', '/protocols/templates'),
+    enabled: options.enabled,
+    staleTime: 30_000,
+  })
+}
+
+export function useProtocolRunsQuery(options: ProtocolRunListQueryOptions = {}) {
+  const params = normalizeRunListParams(options)
+  return useQuery<ProtocolRun[]>({
+    queryKey: protocolQueryKeys.runList(params),
+    queryFn: () => api<ProtocolRun[]>('GET', `/protocols/runs?${buildRunListQueryString(params)}`),
+    enabled: options.enabled,
+    staleTime: 5_000,
+  })
+}
+
+export function useProtocolRunDetailQuery(runId: string | null, options: QueryOptions = {}) {
+  return useQuery<ProtocolRunDetail | null>({
+    queryKey: protocolQueryKeys.runDetail(runId),
+    queryFn: () => api<ProtocolRunDetail>('GET', `/protocols/runs/${runId}`),
+    enabled: options.enabled ?? Boolean(runId),
+    staleTime: 5_000,
+  })
+}
+
+export function useCreateProtocolRunMutation() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: (payload: ProtocolRunCreatePayload) => api<ProtocolRun>('POST', '/protocols/runs', payload),
+    onSuccess: async () => {
+      await queryClient.invalidateQueries({ queryKey: protocolQueryKeys.all })
+    },
+  })
+}
+
+export function useProtocolRunActionMutation() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: ({ runId, payload }: { runId: string; payload: ProtocolRunActionPayload }) =>
+      api('POST', `/protocols/runs/${runId}/actions`, payload),
+    onSettled: async (_data, _error, variables) => {
+      await Promise.all([
+        queryClient.invalidateQueries({ queryKey: protocolQueryKeys.runs() }),
+        queryClient.invalidateQueries({ queryKey: protocolQueryKeys.runDetail(variables.runId) }),
+      ])
+    },
+  })
+}
+
+export function useUpsertProtocolTemplateMutation() {
+  const queryClient = useQueryClient()
+  return useMutation<ProtocolTemplate, Error, { templateId?: string | null; payload: ProtocolTemplatePayload }>({
+    mutationFn: ({ templateId, payload }: { templateId?: string | null; payload: ProtocolTemplatePayload }) =>
+      templateId
+        ? api<ProtocolTemplate>('PATCH', `/protocols/templates/${templateId}`, payload)
+        : api<ProtocolTemplate>('POST', '/protocols/templates', payload),
+    onSuccess: async () => {
+      await queryClient.invalidateQueries({ queryKey: protocolQueryKeys.all })
+    },
+  })
+}
+
+export function useDeleteProtocolTemplateMutation() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: (templateId: string) => api('DELETE', `/protocols/templates/${templateId}`),
+    onSuccess: async () => {
+      await queryClient.invalidateQueries({ queryKey: protocolQueryKeys.all })
+    },
+  })
+}

package/src/features/providers/queries.ts

@@ -0,0 +1,142 @@
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
+import { api } from '@/lib/app/api-client'
+import {
+  createProviderConfig,
+  deleteProviderConfig,
+  fetchProviderConfigs,
+  updateProviderConfig,
+} from '@/lib/provider-config'
+import {
+  fetchProviderModelDiscovery,
+  type DiscoverProviderModelsParams,
+} from '@/lib/provider-model-discovery-client'
+import { fetchProviders } from '@/lib/chat/chats'
+import type {
+  ProviderConfig,
+  ProviderInfo,
+  ProviderModelDiscoveryResult,
+} from '@/types'
+
+type QueryOptions = {
+  enabled?: boolean
+}
+
+interface SaveBuiltinProviderInput {
+  id: string
+  models: string[]
+  isEnabled: boolean
+}
+
+interface SaveCustomProviderInput {
+  id?: string | null
+  data: Partial<ProviderConfig>
+}
+
+interface CheckProviderConnectionInput {
+  provider: string
+  credentialId?: string | null
+  endpoint?: string | null
+}
+
+async function invalidateProviderQueries(queryClient: ReturnType<typeof useQueryClient>) {
+  await queryClient.invalidateQueries({ queryKey: providerQueryKeys.all })
+}
+
+export const providerQueryKeys = {
+  all: ['provider-resources'] as const,
+  catalog: () => ['provider-resources', 'catalog'] as const,
+  configs: () => ['provider-resources', 'configs'] as const,
+}
+
+export function useProvidersQuery(options: QueryOptions = {}) {
+  return useQuery<ProviderInfo[]>({
+    queryKey: providerQueryKeys.catalog(),
+    queryFn: fetchProviders,
+    enabled: options.enabled,
+    staleTime: 30_000,
+  })
+}
+
+export function useProviderConfigsQuery(options: QueryOptions = {}) {
+  return useQuery<ProviderConfig[]>({
+    queryKey: providerQueryKeys.configs(),
+    queryFn: fetchProviderConfigs,
+    enabled: options.enabled,
+    staleTime: 30_000,
+  })
+}
+
+export function useToggleProviderMutation() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: ({ id, isEnabled }: { id: string; isEnabled: boolean }) =>
+      api('PUT', `/providers/${id}`, { isEnabled }),
+    onSuccess: async () => {
+      await invalidateProviderQueries(queryClient)
+    },
+  })
+}
+
+export function useSaveBuiltinProviderMutation() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: async ({ id, models, isEnabled }: SaveBuiltinProviderInput) => {
+      await api('PUT', `/providers/${id}/models`, { models })
+      return api('PUT', `/providers/${id}`, {
+        type: 'builtin',
+        isEnabled,
+      })
+    },
+    onSuccess: async () => {
+      await invalidateProviderQueries(queryClient)
+    },
+  })
+}
+
+export function useSaveCustomProviderMutation() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: ({ id, data }: SaveCustomProviderInput) =>
+      id ? updateProviderConfig(id, data) : createProviderConfig(data),
+    onSuccess: async () => {
+      await invalidateProviderQueries(queryClient)
+    },
+  })
+}
+
+export function useDeleteProviderMutation() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: (id: string) => deleteProviderConfig(id),
+    onSuccess: async () => {
+      await invalidateProviderQueries(queryClient)
+    },
+  })
+}
+
+export function useResetProviderModelsMutation() {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: (id: string) => api('DELETE', `/providers/${id}/models`),
+    onSuccess: async () => {
+      await invalidateProviderQueries(queryClient)
+    },
+  })
+}
+
+export function useCheckProviderConnectionMutation() {
+  return useMutation({
+    mutationFn: ({ provider, credentialId, endpoint }: CheckProviderConnectionInput) =>
+      api<{ ok: boolean; message: string }>('POST', '/setup/check-provider', {
+        provider,
+        credentialId,
+        endpoint,
+      }),
+  })
+}
+
+export function useProviderModelDiscoveryMutation() {
+  return useMutation<ProviderModelDiscoveryResult, Error, DiscoverProviderModelsParams>({
+    mutationFn: fetchProviderModelDiscovery,
+  })
+}

package/src/features/settings/queries.ts

@@ -0,0 +1,20 @@
+import { useQuery } from '@tanstack/react-query'
+import { api } from '@/lib/app/api-client'
+import type { AppSettings } from '@/types'
+
+type QueryOptions = {
+  enabled?: boolean
+}
+
+export const settingsQueryKeys = {
+  app: ['settings', 'app'] as const,
+}
+
+export function useAppSettingsQuery(options: QueryOptions = {}) {
+  return useQuery<AppSettings>({
+    queryKey: settingsQueryKeys.app,
+    queryFn: () => api<AppSettings>('GET', '/settings'),
+    enabled: options.enabled,
+    staleTime: 60_000,
+  })
+}