fix: prevent page reload on run trigger to open remote browser

server/src/browser-management/classes/BrowserPool.ts

@@ -15,6 +15,8 @@ interface BrowserPoolInfo {
      * @default false
      */
     active: boolean,
+
+    isRobotRun?: boolean;
 }
 
 /**
@@ -46,17 +48,29 @@ export class BrowserPool {
      * @param browser remote browser instance
      * @param active states if the browser's instance is being actively used
      */
-    public addRemoteBrowser = (id: string, browser: RemoteBrowser, active: boolean = false): void => {
+    public addRemoteBrowser = (id: string, browser: RemoteBrowser, active: boolean = false, isRobotRun: boolean = false): void => {
         this.pool = {
             ...this.pool,
             [id]: {
                 browser,
                 active,
+                isRobotRun
             },
         }
         logger.log('debug', `Remote browser with id: ${id} added to the pool`);
     };
 
+    public hasActiveRobotRun(): boolean {
+        return Object.values(this.pool).some(info => info.isRobotRun);
+    }
+
+    public clearRobotRunState(id: string): void {
+        if (this.pool[id]) {
+            this.pool[id].isRobotRun = false;
+            logger.log('debug', `Robot run state cleared for browser ${id}`);
+        }
+    }
+
     /**
      * Removes the remote browser instance from the pool.
      * @param id remote browser instance's id
@@ -67,6 +81,8 @@ export class BrowserPool {
             logger.log('warn', `Remote browser with id: ${id} does not exist in the pool`);
             return false;
         }
+
+        this.clearRobotRunState(id);
         delete (this.pool[id]);
         logger.log('debug', `Remote browser with id: ${id} deleted from the pool`);
         return true;
@@ -97,4 +113,4 @@ export class BrowserPool {
         logger.log('warn', `No active browser in the pool`);
         return null;
     };
-}
+}

server/src/browser-management/controller.ts

@@ -59,7 +59,7 @@ export const createRemoteBrowserForRun = (userId: string): string => {
     async (socket: Socket) => {
       const browserSession = new RemoteBrowser(socket);
       await browserSession.initialize(userId);
-      browserPool.addRemoteBrowser(id, browserSession, true);
+      browserPool.addRemoteBrowser(id, browserSession, true, true);
       socket.emit('ready-for-run');
     });
   return id;
@@ -154,4 +154,4 @@ export const stopRunningInterpretation = async () => {
   } else {
     logger.log('error', 'Cannot stop interpretation: No active browser or generator.');
   }
-};
+};

server/src/routes/record.ts

@@ -16,6 +16,7 @@ import stealthPlugin from 'puppeteer-extra-plugin-stealth';
 import logger from "../logger";
 import { getDecryptedProxyConfig } from './proxy';
 import { requireSignIn } from '../middlewares/auth';
+import { browserPool } from '../server';
 
 export const router = Router();
 chromium.use(stealthPlugin());
@@ -33,6 +34,17 @@ router.all('/', requireSignIn, (req, res, next) => {
     next() // pass control to the next handler
 })
 
+router.use('/', requireSignIn, (req: AuthenticatedRequest, res: Response, next) => {
+    if (browserPool.hasActiveRobotRun()) {
+        logger.log('debug', 'Preventing browser initialization - robot run in progress');
+        return res.status(403).json({
+            error: 'Cannot initialize recording browser while a robot run is in progress'
+        });
+    }
+    next();
+});
+
+
 /**
  * GET endpoint for starting the remote browser recording session.
  * returns session's id
@@ -131,4 +143,4 @@ router.get('/interpret', requireSignIn, async (req, res) => {
 router.get('/interpret/stop', requireSignIn, async (req, res) => {
     await stopRunningInterpretation();
     return res.send('interpretation stopped');
-});
+});

server/src/routes/storage.ts

@@ -497,6 +497,11 @@ router.put('/runs/:id', requireSignIn, async (req: AuthenticatedRequest, res) =>
       binaryOutput: {},
     });
 
+    const job = await workflowQueue.add(
+      'run workflow',
+      { id, runId, userId: req.user.id, isScheduled: false },
+    );
+
     const plainRun = run.toJSON();
 
     return res.send({

server/src/worker.ts

@@ -1,7 +1,8 @@
 import { Queue, Worker } from 'bullmq';
 import IORedis from 'ioredis';
 import logger from './logger';
-import { handleRunRecording } from "./workflow-management/scheduler";
+import { handleRunRecording as handleScheduledRunRecording } from "./workflow-management/scheduler";
+import { handleRunRecording } from './workflow-management/record';
 import Robot from './models/Robot';
 import { computeNextRun } from './utils/schedule';
 
@@ -22,9 +23,11 @@ connection.on('error', (err) => {
 const workflowQueue = new Queue('workflow', { connection });
 
 const worker = new Worker('workflow', async job => {
-    const { runId, userId, id } = job.data;
+    const { runId, userId, id, isScheduled = true } = job.data;
     try {
-        const result = await handleRunRecording(id, userId);
+        const result = isScheduled ? 
+            await handleScheduledRunRecording(id, userId) : 
+            await handleRunRecording(id, userId, runId);
         return result;
     } catch (error) {
         logger.error('Error running workflow:', error);
@@ -34,23 +37,26 @@ const worker = new Worker('workflow', async job => {
 
 worker.on('completed', async (job: any) => {
     logger.log(`info`, `Job ${job.id} completed for ${job.data.runId}`);
-    const robot = await Robot.findOne({ where: { 'recording_meta.id': job.data.id } });
-    if (robot) {
-        // Update `lastRunAt` to the current time
-        const lastRunAt = new Date();
+
+    if (job.data.isScheduled) {
+        const robot = await Robot.findOne({ where: { 'recording_meta.id': job.data.id } });
+        if (robot) {
+            // Update `lastRunAt` to the current time
+            const lastRunAt = new Date();
 
-        // Compute the next run date
-        if (robot.schedule && robot.schedule.cronExpression && robot.schedule.timezone) {
-            const nextRunAt = computeNextRun(robot.schedule.cronExpression, robot.schedule.timezone) || undefined;
-            await robot.update({
-                schedule: {
-                    ...robot.schedule,
-                    lastRunAt,
-                    nextRunAt,
-                },
-            });
-        } else {
-            logger.error('Robot schedule, cronExpression, or timezone is missing.');
+            // Compute the next run date
+            if (robot.schedule && robot.schedule.cronExpression && robot.schedule.timezone) {
+                const nextRunAt = computeNextRun(robot.schedule.cronExpression, robot.schedule.timezone) || undefined;
+                await robot.update({
+                    schedule: {
+                        ...robot.schedule,
+                        lastRunAt,
+                        nextRunAt,
+                    },
+                });
+            } else {
+                logger.error('Robot schedule, cronExpression, or timezone is missing.');
+            }
         }
     }
 });

server/src/workflow-management/classes/Interpreter.ts

@@ -332,6 +332,8 @@ export class WorkflowInterpreter {
       }, {})
     }
 
+    this.socket.emit('run-completed', "success");
+
     logger.log('debug', `Interpretation finished`);
     this.clearState();
     return result;
@@ -354,4 +356,4 @@ export class WorkflowInterpreter {
     this.socket = socket;
     this.subscribeToPausing();
   };
-}
+}

src/pages/MainPage.tsx

@@ -68,13 +68,14 @@ export const MainPage = ({ handleEditRecording, initialContent }: MainPageProps)
   const readyForRunHandler = useCallback((browserId: string, runId: string) => {
     interpretStoredRecording(runId).then(async (interpretation: boolean) => {
       if (!aborted) {
-        if (interpretation) {
-          notify('success', t('main_page.notifications.interpretation_success', { name: runningRecordingName }));
-        } else {
-          notify('success', t('main_page.notifications.interpretation_failed', { name: runningRecordingName }));
-          // destroy the created browser
-          await stopRecording(browserId);
-        }
+        // if (interpretation) {
+        //   notify('success', t('main_page.notifications.interpretation_success', { name: runningRecordingName }));
+        // } else {
+        //   notify('success', t('main_page.notifications.interpretation_failed', { name: runningRecordingName }));
+        //   // destroy the created browser
+        //   await stopRecording(browserId);
+        // }
+        if (!interpretation) await stopRecording(browserId);
       }
       setRunningRecordingName('');
       setCurrentInterpretationLog('');
@@ -96,8 +97,19 @@ export const MainPage = ({ handleEditRecording, initialContent }: MainPageProps)
           rejectUnauthorized: false
         });
       setSockets(sockets => [...sockets, socket]);
-      socket.on('ready-for-run', () => readyForRunHandler(browserId, runId));
       socket.on('debugMessage', debugMessageHandler);
+
+      socket.on('run-completed', (status) => {
+        if (status === 'success') {
+            notify('success', t('main_page.notifications.interpretation_success', { name: runningRecordingName }));
+        } else {
+            notify('error', t('main_page.notifications.interpretation_failed', { name: runningRecordingName }));
+        }
+        setRunningRecordingName('');
+        setCurrentInterpretationLog('');
+        setRerenderRuns(true);
+      });
+
       setContent('runs');
       if (browserId) {
         notify('info', t('main_page.notifications.run_started', { name: runningRecordingName }));
@@ -106,10 +118,10 @@ export const MainPage = ({ handleEditRecording, initialContent }: MainPageProps)
       }
     })
     return (socket: Socket, browserId: string, runId: string) => {
-      socket.off('ready-for-run', () => readyForRunHandler(browserId, runId));
       socket.off('debugMessage', debugMessageHandler);
+      socket.off('run-completed');
     }
-  }, [runningRecordingName, sockets, ids, readyForRunHandler, debugMessageHandler])
+  }, [runningRecordingName, sockets, ids, debugMessageHandler])
 
   const handleScheduleRecording = (settings: ScheduleSettings) => {
     scheduleStoredRecording(runningRecordingId, settings)