Merge pull request #1017 from getmaxun/success-fix

fix: success status being displayed

Author: amhsirak

package.json

@@ -88,7 +88,7 @@
     "start": "npm run build:server && concurrently -k \"npm run server\" \"npm run client\"",
     "server": "cross-env NODE_OPTIONS='--max-old-space-size=4096' node server/dist/server/src/server.js",
     "start:dev": "concurrently -k \"npm run server:dev\" \"npm run client\"",
-    "server:dev": "cross-env NODE_OPTIONS='--max-old-space-size=2048' nodemon server/src/server.ts",
+    "server:dev": "cross-env NODE_OPTIONS='--max-old-space-size=4096' nodemon server/src/server.ts",
     "client": "vite",
     "build": "vite build",
     "build:server": "tsc -p server/tsconfig.json",

src/components/robot/pages/RobotCreate.tsx

@@ -99,7 +99,7 @@ const RobotCreate: React.FC = () => {
 
   const { state } = React.useContext(AuthContext);
   const { user } = state;
-  const { addOptimisticRobot, removeOptimisticRobot, invalidateRecordings, invalidateRuns, addOptimisticRun } = useCacheInvalidation();
+  const { addOptimisticRobot, removeOptimisticRobot, invalidateRecordings, invalidateRuns, updateOptimisticRun } = useCacheInvalidation();
 
   const handleTabChange = (event: React.SyntheticEvent, newValue: number) => {
     setTabValue(newValue);
@@ -621,7 +621,7 @@ const RobotCreate: React.FC = () => {
                             isOptimistic: true
                           };
 
-                          addOptimisticRun(optimisticRun);
+                          updateOptimisticRun(optimisticRun);
 
                           const runResponse = await createAndRunRecording(robotMetaId, {
                             maxConcurrency: 1,

src/context/globalInfo.tsx

@@ -176,9 +176,18 @@ export const useCacheInvalidation = () => {
     queryClient.invalidateQueries({ queryKey: dataCacheKeys.recordings });
   };
 
-  const addOptimisticRun = (newRun: any) => {
+  const updateOptimisticRun = (newRun: any, oldRunId?: string) => {
     queryClient.setQueryData(dataCacheKeys.runs, (oldData: any) => {
       if (!oldData) return [{ id: 0, ...newRun }];
+      const runToMatch = oldRunId || newRun.runId;
+      const existingIndex = oldData.findIndex((r: any) => r.runId === runToMatch);
+
+      if (existingIndex !== -1) {
+        const newData = [...oldData];
+        newData[existingIndex] = { ...newData[existingIndex], ...newRun };
+        return newData;
+      }
+
       return [{ id: oldData.length, ...newRun }, ...oldData];
     });
   };
@@ -205,7 +214,7 @@ export const useCacheInvalidation = () => {
   return {
     invalidateRuns,
     invalidateRecordings,
-    addOptimisticRun,
+    updateOptimisticRun,
     addOptimisticRobot,
     removeOptimisticRobot,
     invalidateAllCache

src/pages/MainPage.tsx

@@ -23,9 +23,10 @@ interface MainPageProps {
 }
 
 export interface CreateRunResponse {
-  browserId: string;
+  browserId: string | null;
   runId: string;
   robotMetaId: string;
+  httpExecution?: boolean;
 }
 
 export interface ScheduleRunResponse {
@@ -50,7 +51,7 @@ export const MainPage = ({ handleEditRecording, initialContent }: MainPageProps)
   let aborted = false;
 
   const { notify, setRerenderRuns, setRecordingId } = useGlobalInfoStore();
-  const { invalidateRuns, addOptimisticRun } = useCacheInvalidation();
+  const { invalidateRuns, updateOptimisticRun } = useCacheInvalidation();
   const navigate  = useNavigate();
 
   React.useEffect(() => {
@@ -157,19 +158,36 @@ export const MainPage = ({ handleEditRecording, initialContent }: MainPageProps)
       isOptimistic: true
     };
 
-    addOptimisticRun(optimisticRun);
+    updateOptimisticRun(optimisticRun);
+    setIds({ browserId: '', runId: optimisticRun.runId, robotMetaId: runningRecordingId });
+    navigate(`/runs/${runningRecordingId}/run/${optimisticRun.runId}`);
 
     createAndRunRecording(runningRecordingId, settings).then((response: CreateRunResponseWithQueue) => {
       invalidateRuns();
       const { browserId, runId, robotMetaId, queued } = response;
 
+      if (!runId && !queued) {
+        notify('error', t('main_page.notifications.run_start_failed', { name: runningRecordingName }));
+        setContent('robots');
+        return;
+      }
+
+      const realRun = {
+        ...optimisticRun,
+        runId,
+        status: browserId === null ? 'success' : (queued ? 'queued' : 'running'),
+        isOptimistic: true
+      };
+
+      updateOptimisticRun(realRun, optimisticRun.runId);
+
       setIds({ browserId, runId, robotMetaId });
       navigate(`/runs/${robotMetaId}/run/${runId}`);
 
       if (queued) {
         setQueuedRuns(prev => new Set([...prev, runId]));
         notify('info', `Run queued: ${runningRecordingName}`);
-      } else {
+      } else if (browserId) {
         const socket = io(`${apiUrl}/${browserId}`, {
           transports: ["websocket", "polling"],
           rejectUnauthorized: false
@@ -205,6 +223,8 @@ export const MainPage = ({ handleEditRecording, initialContent }: MainPageProps)
         } else {
           notify('error', t('main_page.notifications.run_start_failed', { name: runningRecordingName }));
         }
+      } else if (runId) {
+        notify('info', t('main_page.notifications.run_started', { name: runningRecordingName }));
       }
 
       setContent('runs');
@@ -218,7 +238,7 @@ export const MainPage = ({ handleEditRecording, initialContent }: MainPageProps)
       socket.off('connect_error');
       socket.off('disconnect');
     }
-  }, [runningRecordingName, sockets, ids, debugMessageHandler, user?.id, t, notify, setRerenderRuns, setQueuedRuns, navigate, setContent, setIds, invalidateRuns, addOptimisticRun, runningRecordingId]);
+  }, [runningRecordingName, sockets, ids, debugMessageHandler, user?.id, t, notify, setRerenderRuns, setQueuedRuns, navigate, setContent, setIds, invalidateRuns, updateOptimisticRun, runningRecordingId]);
 
   useEffect(() => {
     return () => {