@nextclaw/ui 0.11.0 → 0.11.1

package/src/hooks/useConfig.ts

@@ -17,21 +17,12 @@ import {
   updateRuntime,
   updateSecrets,
   executeConfigAction,
-  fetchSessions,
-  fetchSessionHistory,
-  updateSession,
-  deleteSession,
-  sendChatTurn,
-  fetchChatRun,
-  fetchChatRuns,
-  fetchChatCapabilities,
-  fetchChatSessionTypes,
   fetchCronJobs,
   deleteCronJob,
   setCronJobEnabled,
   runCronJob
 } from '@/api/config';
-import { deleteNcpSession, fetchNcpSessionMessages, fetchNcpSessions } from '@/api/ncp-session';
+import { deleteNcpSession, fetchNcpSessionMessages, fetchNcpSessions, updateNcpSession } from '@/api/ncp-session';
 import { toast } from 'sonner';
 import { t } from '@/lib/i18n';
 
@@ -234,25 +225,6 @@ export function useExecuteConfigAction() {
   });
 }
 
-
-export function useSessions(params: { q?: string; limit?: number; activeMinutes?: number }) {
-  return useQuery({
-    queryKey: ['sessions', params],
-    queryFn: () => fetchSessions(params),
-    staleTime: 10_000
-  });
-}
-
-export function useSessionHistory(key: string | null, limit = 200) {
-  return useQuery({
-    queryKey: ['session-history', key, limit],
-    queryFn: () => fetchSessionHistory(key as string, limit),
-    enabled: Boolean(key),
-    staleTime: 5_000,
-    retry: false
-  });
-}
-
 export function useNcpSessions(params?: { limit?: number }) {
   return useQuery({
     queryKey: ['ncp-sessions', params?.limit ?? null],
@@ -276,31 +248,14 @@ export function useNcpSessionMessages(sessionId: string | null, limit = 200) {
   });
 }
 
-export function useUpdateSession() {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: ({ key, data }: { key: string; data: Parameters<typeof updateSession>[1] }) =>
-      updateSession(key, data),
-    onSuccess: (_data, variables) => {
-      queryClient.invalidateQueries({ queryKey: ['sessions'] });
-      queryClient.invalidateQueries({ queryKey: ['session-history', variables.key] });
-      toast.success(t('configSavedApplied'));
-    },
-    onError: (error: Error) => {
-      toast.error(t('configSaveFailed') + ': ' + error.message);
-    }
-  });
-}
-
-export function useDeleteSession() {
+export function useDeleteNcpSession() {
   const queryClient = useQueryClient();
 
   return useMutation({
-    mutationFn: ({ key }: { key: string }) => deleteSession(key),
+    mutationFn: ({ sessionId }: { sessionId: string }) => deleteNcpSession(sessionId),
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ['sessions'] });
-      queryClient.invalidateQueries({ queryKey: ['session-history'] });
+      queryClient.invalidateQueries({ queryKey: ['ncp-sessions'] });
+      queryClient.invalidateQueries({ queryKey: ['ncp-session-messages'] });
       toast.success(t('configSavedApplied'));
     },
     onError: (error: Error) => {
@@ -309,14 +264,15 @@ export function useDeleteSession() {
   });
 }
 
-export function useDeleteNcpSession() {
+export function useUpdateNcpSession() {
   const queryClient = useQueryClient();
 
   return useMutation({
-    mutationFn: ({ sessionId }: { sessionId: string }) => deleteNcpSession(sessionId),
-    onSuccess: () => {
+    mutationFn: ({ sessionId, data }: { sessionId: string; data: Parameters<typeof updateNcpSession>[1] }) =>
+      updateNcpSession(sessionId, data),
+    onSuccess: (_data, variables) => {
       queryClient.invalidateQueries({ queryKey: ['ncp-sessions'] });
-      queryClient.invalidateQueries({ queryKey: ['ncp-session-messages'] });
+      queryClient.invalidateQueries({ queryKey: ['ncp-session-messages', variables.sessionId] });
       toast.success(t('configSavedApplied'));
     },
     onError: (error: Error) => {
@@ -325,89 +281,6 @@ export function useDeleteNcpSession() {
   });
 }
 
-export function useSendChatTurn() {
-  return useMutation({
-    mutationFn: ({ data }: { data: Parameters<typeof sendChatTurn>[0] }) =>
-      sendChatTurn(data),
-    onError: (error: Error) => {
-      toast.error(t('chatSendFailed') + ': ' + error.message);
-    }
-  });
-}
-
-export function useChatCapabilities(params?: { sessionKey?: string | null; agentId?: string | null }) {
-  const sessionKey = params?.sessionKey?.trim() || undefined;
-  const agentId = params?.agentId?.trim() || undefined;
-  return useQuery({
-    queryKey: ['chat-capabilities', sessionKey ?? null, agentId ?? null],
-    queryFn: async () => {
-      try {
-        return await fetchChatCapabilities({ sessionKey, agentId });
-      } catch {
-        return { stopSupported: false };
-      }
-    },
-    staleTime: 10_000,
-    retry: false
-  });
-}
-
-export function useChatSessionTypes() {
-  return useQuery({
-    queryKey: ['chat-session-types'],
-    queryFn: fetchChatSessionTypes,
-    staleTime: 10_000,
-    retry: false
-  });
-}
-
-export function useChatRuns(params?: {
-  sessionKey?: string | null;
-  states?: Array<'queued' | 'running' | 'completed' | 'failed' | 'aborted'>;
-  limit?: number;
-  syncActiveStates?: boolean;
-  isLocallyRunning?: boolean;
-}) {
-  const sessionKey = params?.sessionKey?.trim() || undefined;
-  const states = Array.isArray(params?.states) && params.states.length > 0 ? params.states : undefined;
-  const isActiveStatesQuery = Boolean(states?.some((state) => state === 'queued' || state === 'running'));
-  const shouldSyncActiveStates = Boolean(params?.syncActiveStates && isActiveStatesQuery);
-  return useQuery({
-    queryKey: ['chat-runs', sessionKey ?? null, states ?? null, params?.limit ?? null],
-    queryFn: () => fetchChatRuns({
-      ...(sessionKey ? { sessionKey } : {}),
-      ...(states ? { states } : {}),
-      ...(typeof params?.limit === 'number' ? { limit: params.limit } : {})
-    }),
-    enabled: Boolean(sessionKey) || Boolean(states),
-    staleTime: 5_000,
-    refetchInterval: (query) => {
-      if (!shouldSyncActiveStates) {
-        return false;
-      }
-      if (params?.isLocallyRunning) {
-        return 800;
-      }
-      const { data } = query.state;
-      const hasActiveRuns = Array.isArray(data?.runs) && data.runs.length > 0;
-      return hasActiveRuns ? 800 : false;
-    },
-    refetchIntervalInBackground: false,
-    retry: false
-  });
-}
-
-export function useChatRun(runId: string | null) {
-  const normalizedRunId = runId?.trim() || null;
-  return useQuery({
-    queryKey: ['chat-run', normalizedRunId],
-    queryFn: () => fetchChatRun(normalizedRunId as string),
-    enabled: Boolean(normalizedRunId),
-    staleTime: 5_000,
-    retry: false
-  });
-}
-
 export function useCronJobs(params: { all?: boolean } = { all: true }) {
   return useQuery({
     queryKey: ['cron', params],

package/src/lib/session-run-status.ts

@@ -1,63 +1 @@
-import type { ChatRunState, ChatRunView } from '@/api/types';
-
-export type SessionRunStatus = Extract<ChatRunState, 'queued' | 'running'>;
-
-const RUN_STATUS_PRIORITY: Record<SessionRunStatus, number> = {
-  queued: 1,
-  running: 2
-};
-
-function toSessionRunStatus(state: ChatRunState): SessionRunStatus | null {
-  if (state === 'queued' || state === 'running') {
-    return state;
-  }
-  return null;
-}
-
-function toComparableTimestamp(value?: string): number {
-  const parsed = Date.parse(value ?? '');
-  return Number.isFinite(parsed) ? parsed : 0;
-}
-
-function shouldReplaceRun(current: ChatRunView, next: ChatRunView): boolean {
-  const currentStatus = toSessionRunStatus(current.state);
-  const nextStatus = toSessionRunStatus(next.state);
-  if (!currentStatus || !nextStatus) {
-    return false;
-  }
-  const currentPriority = RUN_STATUS_PRIORITY[currentStatus];
-  const nextPriority = RUN_STATUS_PRIORITY[nextStatus];
-  if (nextPriority !== currentPriority) {
-    return nextPriority > currentPriority;
-  }
-  return toComparableTimestamp(next.requestedAt) >= toComparableTimestamp(current.requestedAt);
-}
-
-export function buildActiveRunBySessionKey(runs: readonly ChatRunView[]): Map<string, ChatRunView> {
-  const map = new Map<string, ChatRunView>();
-  for (const run of runs) {
-    const key = run.sessionKey?.trim();
-    if (!key || !toSessionRunStatus(run.state)) {
-      continue;
-    }
-    const current = map.get(key);
-    if (!current || shouldReplaceRun(current, run)) {
-      map.set(key, run);
-    }
-  }
-  return map;
-}
-
-export function buildSessionRunStatusByKey(
-  activeRunBySessionKey: ReadonlyMap<string, ChatRunView>
-): Map<string, SessionRunStatus> {
-  const map = new Map<string, SessionRunStatus>();
-  for (const [sessionKey, run] of activeRunBySessionKey.entries()) {
-    const status = toSessionRunStatus(run.state);
-    if (!status) {
-      continue;
-    }
-    map.set(sessionKey, status);
-  }
-  return map;
-}
+export type SessionRunStatus = 'queued' | 'running';

package/src/vite-env.d.ts

@@ -2,6 +2,7 @@
 
 interface ImportMetaEnv {
   readonly VITE_API_BASE?: string;
+  readonly VITE_DEV_PROXY_API_BASE?: string;
 }
 
 interface ImportMeta {

package/vite.config.ts

@@ -2,8 +2,8 @@ import { defineConfig, splitVendorChunkPlugin } from 'vite';
 import react from '@vitejs/plugin-react';
 import path from 'path';
 
-const apiBase = process.env.VITE_API_BASE ?? 'http://127.0.0.1:18792';
-const wsBase = apiBase.replace(/^http/i, 'ws');
+const devProxyApiBase = process.env.VITE_DEV_PROXY_API_BASE ?? 'http://127.0.0.1:18792';
+const devProxyWsBase = devProxyApiBase.replace(/^http/i, 'ws');
 
 export default defineConfig({
   plugins: [react(), splitVendorChunkPlugin()],
@@ -20,11 +20,11 @@ export default defineConfig({
     strictPort: true,
     proxy: {
       '/api': {
-        target: apiBase,
+        target: devProxyApiBase,
         changeOrigin: true
       },
       '/ws': {
-        target: wsBase,
+        target: devProxyWsBase,
         ws: true
       }
     }