Instance-namespace various endpoints and services.

src/services/api/hooks/useOperations.ts

@@ -26,11 +26,11 @@ export const useOperations = (instanceName: string, filter?: 'running' | 'comple
   });
 };
 
-export const useOperation = (operationId: string) => {
+export const useOperation = (instanceName: string, operationId: string) => {
   return useQuery<Operation>({
-    queryKey: ['operation', operationId],
-    queryFn: () => operationsApi.get(operationId),
-    enabled: !!operationId,
+    queryKey: ['operation', instanceName, operationId],
+    queryFn: () => operationsApi.get(instanceName, operationId),
+    enabled: !!instanceName && !!operationId,
     refetchInterval: (query) => {
       // Stop polling if operation is completed, failed, or cancelled
       const status = query.state.data?.status;
@@ -47,12 +47,12 @@ export const useCancelOperation = () => {
   const queryClient = useQueryClient();
 
   return useMutation({
-    mutationFn: ({ operationId, instanceName }: { operationId: string; instanceName: string }) =>
-      operationsApi.cancel(operationId, instanceName),
-    onSuccess: (_, { operationId }) => {
+    mutationFn: ({ instanceName, operationId }: { instanceName: string; operationId: string }) =>
+      operationsApi.cancel(instanceName, operationId),
+    onSuccess: (_, { instanceName, operationId }) => {
       // Invalidate operation queries to refresh data
-      queryClient.invalidateQueries({ queryKey: ['operation', operationId] });
-      queryClient.invalidateQueries({ queryKey: ['operations'] });
+      queryClient.invalidateQueries({ queryKey: ['operation', instanceName, operationId] });
+      queryClient.invalidateQueries({ queryKey: ['operations', instanceName] });
     },
   });
 };

src/services/api/hooks/useUtilities.ts

@@ -1,44 +1,39 @@
 import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
 import { utilitiesApi } from '../utilities';
 
-export function useDashboardToken() {
+export function useDashboardToken(instanceName: string) {
   return useQuery({
-    queryKey: ['utilities', 'dashboard', 'token'],
-    queryFn: utilitiesApi.getDashboardToken,
-    staleTime: 5 * 60 * 1000, // 5 minutes
-  });
-}
-
-export function useInstanceDashboardToken(instanceId: string) {
-  return useQuery({
-    queryKey: ['instances', instanceId, 'utilities', 'dashboard', 'token'],
-    queryFn: () => utilitiesApi.getInstanceDashboardToken(instanceId),
+    queryKey: ['instances', instanceName, 'utilities', 'dashboard', 'token'],
+    queryFn: () => utilitiesApi.getDashboardToken(instanceName),
     staleTime: 30 * 60 * 1000, // 30 minutes
-    enabled: !!instanceId,
+    enabled: !!instanceName,
   });
 }
 
-export function useClusterVersions() {
+export function useClusterVersions(instanceName: string) {
   return useQuery({
-    queryKey: ['utilities', 'version'],
-    queryFn: utilitiesApi.getVersion,
+    queryKey: ['instances', instanceName, 'utilities', 'version'],
+    queryFn: () => utilitiesApi.getVersion(instanceName),
     staleTime: 10 * 60 * 1000, // 10 minutes
+    enabled: !!instanceName,
   });
 }
 
-export function useNodeIPs() {
+export function useNodeIPs(instanceName: string) {
   return useQuery({
-    queryKey: ['utilities', 'nodes', 'ips'],
-    queryFn: utilitiesApi.getNodeIPs,
+    queryKey: ['instances', instanceName, 'utilities', 'nodes', 'ips'],
+    queryFn: () => utilitiesApi.getNodeIPs(instanceName),
     staleTime: 30 * 1000, // 30 seconds
+    enabled: !!instanceName,
   });
 }
 
-export function useControlPlaneIP() {
+export function useControlPlaneIP(instanceName: string) {
   return useQuery({
-    queryKey: ['utilities', 'controlplane', 'ip'],
-    queryFn: utilitiesApi.getControlPlaneIP,
+    queryKey: ['instances', instanceName, 'utilities', 'controlplane', 'ip'],
+    queryFn: () => utilitiesApi.getControlPlaneIP(instanceName),
     staleTime: 60 * 1000, // 1 minute
+    enabled: !!instanceName,
   });
 }
 
@@ -46,8 +41,12 @@ export function useCopySecret() {
   const queryClient = useQueryClient();
 
   return useMutation({
-    mutationFn: ({ secret, targetInstance }: { secret: string; targetInstance: string }) =>
-      utilitiesApi.copySecret(secret, targetInstance),
+    mutationFn: ({ instanceName, secret, sourceNamespace, destinationNamespace }: {
+      instanceName: string;
+      secret: string;
+      sourceNamespace: string;
+      destinationNamespace: string;
+    }) => utilitiesApi.copySecret(instanceName, secret, sourceNamespace, destinationNamespace),
     onSuccess: () => {
       // Invalidate secrets queries
       queryClient.invalidateQueries({ queryKey: ['secrets'] });

src/services/api/operations.ts

@@ -6,18 +6,17 @@ export const operationsApi = {
     return apiClient.get(`/api/v1/instances/${instanceName}/operations`);
   },
 
-  async get(operationId: string, instanceName?: string): Promise<Operation> {
-    const params = instanceName ? `?instance=${instanceName}` : '';
-    return apiClient.get(`/api/v1/operations/${operationId}${params}`);
+  async get(instanceName: string, operationId: string): Promise<Operation> {
+    return apiClient.get(`/api/v1/instances/${instanceName}/operations/${operationId}`);
   },
 
-  async cancel(operationId: string, instanceName: string): Promise<{ message: string }> {
-    return apiClient.post(`/api/v1/operations/${operationId}/cancel?instance=${instanceName}`);
+  async cancel(instanceName: string, operationId: string): Promise<{ message: string }> {
+    return apiClient.post(`/api/v1/instances/${instanceName}/operations/${operationId}/cancel`);
   },
 
   // SSE stream for operation updates
-  createStream(operationId: string): EventSource {
+  createStream(instanceName: string, operationId: string): EventSource {
     const baseUrl = import.meta.env.VITE_API_BASE_URL || 'http://localhost:5055';
-    return new EventSource(`${baseUrl}/api/v1/operations/${operationId}/stream`);
+    return new EventSource(`${baseUrl}/api/v1/instances/${instanceName}/operations/${operationId}/stream`);
   },
 };

src/services/api/utilities.ts

@@ -11,37 +11,31 @@ export interface VersionResponse {
 }
 
 export const utilitiesApi = {
-  async health(): Promise<HealthResponse> {
-    return apiClient.get('/api/v1/utilities/health');
-  },
-
-  async instanceHealth(instanceName: string): Promise<HealthResponse> {
+  async health(instanceName: string): Promise<HealthResponse> {
     return apiClient.get(`/api/v1/instances/${instanceName}/utilities/health`);
   },
 
-  async getDashboardToken(): Promise<{ token: string }> {
-    const response = await apiClient.get<{ data: { token: string }; success: boolean }>('/api/v1/utilities/dashboard/token');
-    return response.data;
-  },
-
-  async getInstanceDashboardToken(instanceName: string): Promise<{ token: string }> {
+  async getDashboardToken(instanceName: string): Promise<{ token: string }> {
     const response = await apiClient.get<{ data: { token: string }; success: boolean }>(`/api/v1/instances/${instanceName}/utilities/dashboard/token`);
     return response.data;
   },
 
-  async getNodeIPs(): Promise<{ ips: string[] }> {
-    return apiClient.get('/api/v1/utilities/nodes/ips');
+  async getNodeIPs(instanceName: string): Promise<{ ips: string[] }> {
+    return apiClient.get(`/api/v1/instances/${instanceName}/utilities/nodes/ips`);
   },
 
-  async getControlPlaneIP(): Promise<{ ip: string }> {
-    return apiClient.get('/api/v1/utilities/controlplane/ip');
+  async getControlPlaneIP(instanceName: string): Promise<{ ip: string }> {
+    return apiClient.get(`/api/v1/instances/${instanceName}/utilities/controlplane/ip`);
   },
 
-  async copySecret(secret: string, targetInstance: string): Promise<{ message: string }> {
-    return apiClient.post(`/api/v1/utilities/secrets/${secret}/copy`, { target: targetInstance });
+  async copySecret(instanceName: string, secret: string, sourceNamespace: string, destinationNamespace: string): Promise<{ message: string }> {
+    return apiClient.post(`/api/v1/instances/${instanceName}/utilities/secrets/${secret}/copy`, {
+      source_namespace: sourceNamespace,
+      destination_namespace: destinationNamespace
+    });
   },
 
-  async getVersion(): Promise<VersionResponse> {
-    return apiClient.get('/api/v1/utilities/version');
+  async getVersion(instanceName: string): Promise<VersionResponse> {
+    return apiClient.get(`/api/v1/instances/${instanceName}/utilities/version`);
   },
 };