From 6f291c4237b678cfb1aad458c2548f3d6fb3d28c Mon Sep 17 00:00:00 2001
From: Karishma Shukla <carishmashukla28@gmail.com>
Date: Wed, 4 Jun 2025 18:10:11 +0530
Subject: [PATCH 1/7] feat: allow stopping queued runs

---
 src/components/run/RunContent.tsx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/components/run/RunContent.tsx b/src/components/run/RunContent.tsx
index faa425d3..f50ffeed 100644
--- a/src/components/run/RunContent.tsx
+++ b/src/components/run/RunContent.tsx
@@ -441,7 +441,7 @@ export const RunContent = ({ row, currentLog, interpretationInProgress, logEndRe
                 ref={logEndRef} />
             </div>
           </Box>
-          {row.status === 'running' ? <Button
+          {row.status === 'running' || row.status === 'queued' ? <Button
             color="error"
             onClick={abortRunHandler}
           >
@@ -595,4 +595,4 @@ export const RunContent = ({ row, currentLog, interpretationInProgress, logEndRe
       </TabContext>
     </Box>
   );
-};
\ No newline at end of file
+};

From c1097c801b65456b3275c912ae95cf8873a29b5b Mon Sep 17 00:00:00 2001
From: Karishma Shukla <carishmashukla28@gmail.com>
Date: Wed, 4 Jun 2025 18:11:15 +0530
Subject: [PATCH 2/7] feat: rerender runs on abort

---
 src/pages/MainPage.tsx | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/pages/MainPage.tsx b/src/pages/MainPage.tsx
index 8d1a623c..f2559666 100644
--- a/src/pages/MainPage.tsx
+++ b/src/pages/MainPage.tsx
@@ -58,6 +58,7 @@ export const MainPage = ({ handleEditRecording, initialContent }: MainPageProps)
       } else {
         notify('error', t('main_page.notifications.abort_failed', { name: runningRecordingName }));
       }
+      setRerenderRuns(true);
     })
   }
 

From 326dcc8fa32ecf07276e23ea7bafd4328bc3124a Mon Sep 17 00:00:00 2001
From: amhsirak <karishmashuklaa@gmail.com>
Date: Fri, 6 Jun 2025 00:44:12 +0530
Subject: [PATCH 3/7] feat: pass params for abort handler

---
 src/pages/MainPage.tsx | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/pages/MainPage.tsx b/src/pages/MainPage.tsx
index f2559666..b43f5e50 100644
--- a/src/pages/MainPage.tsx
+++ b/src/pages/MainPage.tsx
@@ -49,14 +49,14 @@ export const MainPage = ({ handleEditRecording, initialContent }: MainPageProps)
   const { notify, setRerenderRuns, setRecordingId } = useGlobalInfoStore();
   const navigate  = useNavigate();
 
-  const abortRunHandler = (runId: string) => {
+  const abortRunHandler = (runId: string, robotName: string, browserId: string) => {
     aborted = true;
     notifyAboutAbort(runId).then(async (response) => {
       if (response) {
-        notify('success', t('main_page.notifications.abort_success', { name: runningRecordingName }));
+        notify('success', t('main_page.notifications.abort_success', { name: robotName }));
         await stopRecording(ids.browserId);
       } else {
-        notify('error', t('main_page.notifications.abort_failed', { name: runningRecordingName }));
+        notify('error', t('main_page.notifications.abort_failed', { name: robotName }));
       }
       setRerenderRuns(true);
     })
@@ -157,7 +157,7 @@ export const MainPage = ({ handleEditRecording, initialContent }: MainPageProps)
       case 'runs':
         return <Runs
           currentInterpretationLog={currentInterpretationLog}
-          abortRunHandler={() => abortRunHandler(ids.runId)}
+          abortRunHandler={abortRunHandler}
           runId={ids.runId}
           runningRecordingName={runningRecordingName}
         />;

From b286101575364a615268c5556626ddefd09436ee Mon Sep 17 00:00:00 2001
From: amhsirak <karishmashuklaa@gmail.com>
Date: Fri, 6 Jun 2025 00:46:26 +0530
Subject: [PATCH 4/7] feat: pass params for abort handler

---
 src/components/run/ColapsibleRow.tsx | 4 ++--
 src/components/run/Runs.tsx          | 2 +-
 src/components/run/RunsTable.tsx     | 3 ++-
 3 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/components/run/ColapsibleRow.tsx b/src/components/run/ColapsibleRow.tsx
index eadf0823..d69acb8f 100644
--- a/src/components/run/ColapsibleRow.tsx
+++ b/src/components/run/ColapsibleRow.tsx
@@ -33,7 +33,7 @@ interface CollapsibleRowProps {
   handleDelete: () => void;
   isOpen: boolean;
   currentLog: string;
-  abortRunHandler: () => void;
+  abortRunHandler: (runId: string, robotName: string, browserId: string) => void;
   runningRecordingName: string;
   urlRunId: string | null;
 }
@@ -60,7 +60,7 @@ export const CollapsibleRow = ({ row, handleDelete, isOpen, currentLog, abortRun
   }
 
   const handleAbort = () => {
-    abortRunHandler();
+    abortRunHandler(row.runId, row.name, row.browserId);
   }
 
   useEffect(() => {
diff --git a/src/components/run/Runs.tsx b/src/components/run/Runs.tsx
index 736378f6..4287d006 100644
--- a/src/components/run/Runs.tsx
+++ b/src/components/run/Runs.tsx
@@ -4,7 +4,7 @@ import { RunsTable } from "./RunsTable";
 
 interface RunsProps {
   currentInterpretationLog: string;
-  abortRunHandler: () => void;
+  abortRunHandler: (runId: string, robotName: string, browserId: string) => void;
   runId: string;
   runningRecordingName: string;
 }
diff --git a/src/components/run/RunsTable.tsx b/src/components/run/RunsTable.tsx
index 0864c493..2628bdda 100644
--- a/src/components/run/RunsTable.tsx
+++ b/src/components/run/RunsTable.tsx
@@ -53,6 +53,7 @@ export interface Data {
   finishedAt: string;
   runByUserId?: string;
   runByScheduleId?: string;
+  browserId: string;
   runByAPI?: boolean;
   log: string;
   runId: string;
@@ -65,7 +66,7 @@ export interface Data {
 
 interface RunsTableProps {
   currentInterpretationLog: string;
-  abortRunHandler: () => void;
+  abortRunHandler: (runId: string, robotName: string, browserId: string) => void;
   runId: string;
   runningRecordingName: string;
 }

From d292f6c576d429c3140d1b40077015e4efd0c5b6 Mon Sep 17 00:00:00 2001
From: amhsirak <karishmashuklaa@gmail.com>
Date: Fri, 6 Jun 2025 00:52:16 +0530
Subject: [PATCH 5/7] feat: queue abort run & abort run worker

---
 server/Dockerfile            | 51 ---------------------------
 server/src/routes/storage.ts | 68 +++++++++++++++++++++++++-----------
 2 files changed, 47 insertions(+), 72 deletions(-)
 delete mode 100644 server/Dockerfile

diff --git a/server/Dockerfile b/server/Dockerfile
deleted file mode 100644
index 00310418..00000000
--- a/server/Dockerfile
+++ /dev/null
@@ -1,51 +0,0 @@
-FROM --platform=$BUILDPLATFORM mcr.microsoft.com/playwright:v1.46.0-noble
-
-# Set working directory
-WORKDIR /app
-
-# Install node dependencies
-COPY package*.json ./
-COPY src ./src
-COPY public ./public 
-COPY server ./server
-COPY tsconfig.json ./
-COPY server/tsconfig.json ./server/
-# COPY server/start.sh ./  
-
-# Install dependencies
-RUN npm install --legacy-peer-deps
-
-# Install Playwright browsers and dependencies
-RUN npx playwright install --with-deps chromium
-
-# Create the Chromium data directory with necessary permissions
-RUN mkdir -p /tmp/chromium-data-dir && \
-    chmod -R 777 /tmp/chromium-data-dir
-
-# Install dependencies
-RUN apt-get update && apt-get install -y \
-    libgbm1 \
-    libnss3 \
-    libatk1.0-0 \
-    libatk-bridge2.0-0 \
-    libdrm2 \
-    libxkbcommon0 \
-    libglib2.0-0 \
-    libdbus-1-3 \
-    libx11-xcb1 \
-    libxcb1 \
-    libxcomposite1 \
-    libxcursor1 \
-    libxdamage1 \
-    libxext6 \
-    libxi6 \
-    libxtst6 \
-    && rm -rf /var/lib/apt/lists/* \
-    && mkdir -p /tmp/.X11-unix && chmod 1777 /tmp/.X11-unix
-
-# Expose backend port
-EXPOSE ${BACKEND_PORT:-8080}
-
-# Run migrations & start backend using start script
-#CMD ["npm", "run", "server"]
-CMD ["sh", "-c", "npm run migrate && npm run server"]
\ No newline at end of file
diff --git a/server/src/routes/storage.ts b/server/src/routes/storage.ts
index b4e8cdfd..ee37b2be 100644
--- a/server/src/routes/storage.ts
+++ b/server/src/routes/storage.ts
@@ -889,33 +889,59 @@ router.delete('/schedule/:id', requireSignIn, async (req: AuthenticatedRequest,
  */
 router.post('/runs/abort/:id', requireSignIn, async (req: AuthenticatedRequest, res) => {
   try {
-    if (!req.user) { return res.status(401).send({ error: 'Unauthorized' }); }
-    
-    const run = await Run.findOne({ where: { 
-      runId: req.params.id,
-      runByUserId: req.user.id,
-    } });
-    
-    if (!run) {
-      return res.status(404).send(false);
+    if (!req.user) { 
+      return res.status(401).send({ error: 'Unauthorized' }); 
     }
-    
-    const userQueueName = `abort-run-user-${req.user.id}`;
-    await pgBoss.createQueue(userQueueName);
-    
-    await pgBoss.send(userQueueName, {
-      userId: req.user.id,
-      runId: req.params.id
+
+    const run = await Run.findOne({ 
+      where: { 
+        runId: req.params.id,
+        runByUserId: req.user.id,
+      } 
     });
-    
+
+    if (!run) {
+      return res.status(404).send({ error: 'Run not found' });
+    }
+
+    if (!['running', 'queued'].includes(run.status)) {
+      return res.status(400).send({ 
+        error: `Cannot abort run with status: ${run.status}` 
+      });
+    }
+
     await run.update({
       status: 'aborting'
     });
+
+    if (run.status === 'queued') {
+      await run.update({
+        status: 'aborted',
+        finishedAt: new Date().toLocaleString(),
+        log: 'Run aborted while queued'
+      });
+      
+      return res.send({ success: true, message: 'Queued run aborted' });
+    }
+
+    const userQueueName = `abort-run-user-${req.user.id}`;
+    await pgBoss.createQueue(userQueueName);
     
-    return res.send(true);
+    const jobId = await pgBoss.send(userQueueName, {
+      userId: req.user.id,
+      runId: req.params.id
+    });
+
+    logger.log('info', `Abort signal sent for run ${req.params.id}, job ID: ${jobId}`);
+
+    return res.send({ 
+      success: true, 
+      message: 'Abort signal sent',
+      jobId 
+    });
+
   } catch (e) {
     const { message } = e as Error;
-    logger.log('info', `Error while aborting run with id: ${req.params.id} - ${message}`);
-    return res.send(false);
+    logger.log('error', `Error aborting run ${req.params.id}: ${message}`);
+    return res.status(500).send({ error: 'Failed to abort run' });
   }
-});

From 5d4412fb617e14abffc57efc62e9b3791f7edd45 Mon Sep 17 00:00:00 2001
From: amhsirak <karishmashuklaa@gmail.com>
Date: Fri, 6 Jun 2025 00:52:52 +0530
Subject: [PATCH 6/7] fix: closing {

---
 server/src/routes/storage.ts | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/server/src/routes/storage.ts b/server/src/routes/storage.ts
index ee37b2be..154c50cb 100644
--- a/server/src/routes/storage.ts
+++ b/server/src/routes/storage.ts
@@ -945,3 +945,5 @@ router.post('/runs/abort/:id', requireSignIn, async (req: AuthenticatedRequest,
     logger.log('error', `Error aborting run ${req.params.id}: ${message}`);
     return res.status(500).send({ error: 'Failed to abort run' });
   }
+}
+);
\ No newline at end of file

From a23f2f7bcbdf753c4cf785cec7a13cfe03fc1af6 Mon Sep 17 00:00:00 2001
From: amhsirak <karishmashuklaa@gmail.com>
Date: Fri, 6 Jun 2025 00:53:02 +0530
Subject: [PATCH 7/7] chore: lint

---
 server/src/routes/storage.ts | 264 +++++++++++++++++------------------
 1 file changed, 132 insertions(+), 132 deletions(-)

diff --git a/server/src/routes/storage.ts b/server/src/routes/storage.ts
index 154c50cb..6a010e04 100644
--- a/server/src/routes/storage.ts
+++ b/server/src/routes/storage.ts
@@ -23,7 +23,7 @@ chromium.use(stealthPlugin());
 export const router = Router();
 
 export const processWorkflowActions = async (workflow: any[], checkLimit: boolean = false): Promise<any[]> => {
- const processedWorkflow = JSON.parse(JSON.stringify(workflow));
+  const processedWorkflow = JSON.parse(JSON.stringify(workflow));
 
   processedWorkflow.forEach((pair: any) => {
     pair.what.forEach((action: any) => {
@@ -108,52 +108,52 @@ router.get('/recordings/:id', requireSignIn, async (req, res) => {
 router.get(('/recordings/:id/runs'), requireSignIn, async (req, res) => {
   try {
     const runs = await Run.findAll({
-        where: {
-            robotMetaId: req.params.id
-        },
-        raw: true
+      where: {
+        robotMetaId: req.params.id
+      },
+      raw: true
     });
     const formattedRuns = runs.map(formatRunResponse);
     const response = {
-        statusCode: 200,
-        messageCode: "success",
-        runs: {
+      statusCode: 200,
+      messageCode: "success",
+      runs: {
         totalCount: formattedRuns.length,
         items: formattedRuns,
-        },
+      },
     };
 
     res.status(200).json(response);
-} catch (error) {
+  } catch (error) {
     console.error("Error fetching runs:", error);
     res.status(500).json({
-        statusCode: 500,
-        messageCode: "error",
-        message: "Failed to retrieve runs",
+      statusCode: 500,
+      messageCode: "error",
+      message: "Failed to retrieve runs",
     });
-}
+  }
 })
 
 function formatRunResponse(run: any) {
   const formattedRun = {
-      id: run.id,
-      status: run.status,
-      name: run.name,
-      robotId: run.robotMetaId, // Renaming robotMetaId to robotId
-      startedAt: run.startedAt,
-      finishedAt: run.finishedAt,
-      runId: run.runId,
-      runByUserId: run.runByUserId,
-      runByScheduleId: run.runByScheduleId,
-      runByAPI: run.runByAPI,
-      data: {},
-      screenshot: null,
+    id: run.id,
+    status: run.status,
+    name: run.name,
+    robotId: run.robotMetaId, // Renaming robotMetaId to robotId
+    startedAt: run.startedAt,
+    finishedAt: run.finishedAt,
+    runId: run.runId,
+    runByUserId: run.runByUserId,
+    runByScheduleId: run.runByScheduleId,
+    runByAPI: run.runByAPI,
+    data: {},
+    screenshot: null,
   };
 
   if (run.serializableOutput && run.serializableOutput['item-0']) {
-      formattedRun.data = run.serializableOutput['item-0'];
+    formattedRun.data = run.serializableOutput['item-0'];
   } else if (run.binaryOutput && run.binaryOutput['item-0']) {
-      formattedRun.screenshot = run.binaryOutput['item-0']; 
+    formattedRun.screenshot = run.binaryOutput['item-0'];
   }
 
   return formattedRun;
@@ -170,81 +170,81 @@ interface Credentials {
 
 function handleWorkflowActions(workflow: any[], credentials: Credentials) {
   return workflow.map(step => {
-      if (!step.what) return step;
+    if (!step.what) return step;
 
-      const newWhat: any[] = [];
-      const processedSelectors = new Set<string>();
-      
-      for (let i = 0; i < step.what.length; i++) {
-          const action = step.what[i];
-          
-          if (!action?.action || !action?.args?.[0]) {
-              newWhat.push(action);
-              continue;
-          }
+    const newWhat: any[] = [];
+    const processedSelectors = new Set<string>();
 
-          const selector = action.args[0];
-          const credential = credentials[selector];
+    for (let i = 0; i < step.what.length; i++) {
+      const action = step.what[i];
 
-          if (!credential) {
-              newWhat.push(action);
-              continue;
-          }
-
-          if (action.action === 'click') {
-              newWhat.push(action);
-              
-              if (!processedSelectors.has(selector) && 
-                  i + 1 < step.what.length && 
-                  (step.what[i + 1].action === 'type' || step.what[i + 1].action === 'press')) {
-                  
-                  newWhat.push({
-                      action: 'type',
-                      args: [selector, encrypt(credential.value), credential.type]
-                  });
-                  
-                  newWhat.push({
-                      action: 'waitForLoadState',
-                      args: ['networkidle']
-                  });
-                  
-                  processedSelectors.add(selector);
-                  
-                  while (i + 1 < step.what.length && 
-                         (step.what[i + 1].action === 'type' || 
-                          step.what[i + 1].action === 'press' || 
-                          step.what[i + 1].action === 'waitForLoadState')) {
-                      i++;
-                  }
-              }
-          } else if ((action.action === 'type' || action.action === 'press') && 
-                     !processedSelectors.has(selector)) {
-              newWhat.push({
-                  action: 'type',
-                  args: [selector, encrypt(credential.value), credential.type]
-              });
-              
-              newWhat.push({
-                  action: 'waitForLoadState',
-                  args: ['networkidle']
-              });
-              
-              processedSelectors.add(selector);
-              
-              // Skip subsequent type/press/waitForLoadState actions for this selector
-              while (i + 1 < step.what.length && 
-                     (step.what[i + 1].action === 'type' || 
-                      step.what[i + 1].action === 'press' || 
-                      step.what[i + 1].action === 'waitForLoadState')) {
-                  i++;
-              }
-          }
+      if (!action?.action || !action?.args?.[0]) {
+        newWhat.push(action);
+        continue;
       }
 
-      return {
-          ...step,
-          what: newWhat
-      };
+      const selector = action.args[0];
+      const credential = credentials[selector];
+
+      if (!credential) {
+        newWhat.push(action);
+        continue;
+      }
+
+      if (action.action === 'click') {
+        newWhat.push(action);
+
+        if (!processedSelectors.has(selector) &&
+          i + 1 < step.what.length &&
+          (step.what[i + 1].action === 'type' || step.what[i + 1].action === 'press')) {
+
+          newWhat.push({
+            action: 'type',
+            args: [selector, encrypt(credential.value), credential.type]
+          });
+
+          newWhat.push({
+            action: 'waitForLoadState',
+            args: ['networkidle']
+          });
+
+          processedSelectors.add(selector);
+
+          while (i + 1 < step.what.length &&
+            (step.what[i + 1].action === 'type' ||
+              step.what[i + 1].action === 'press' ||
+              step.what[i + 1].action === 'waitForLoadState')) {
+            i++;
+          }
+        }
+      } else if ((action.action === 'type' || action.action === 'press') &&
+        !processedSelectors.has(selector)) {
+        newWhat.push({
+          action: 'type',
+          args: [selector, encrypt(credential.value), credential.type]
+        });
+
+        newWhat.push({
+          action: 'waitForLoadState',
+          args: ['networkidle']
+        });
+
+        processedSelectors.add(selector);
+
+        // Skip subsequent type/press/waitForLoadState actions for this selector
+        while (i + 1 < step.what.length &&
+          (step.what[i + 1].action === 'type' ||
+            step.what[i + 1].action === 'press' ||
+            step.what[i + 1].action === 'waitForLoadState')) {
+          i++;
+        }
+      }
+    }
+
+    return {
+      ...step,
+      what: newWhat
+    };
   });
 }
 
@@ -275,7 +275,7 @@ router.put('/recordings/:id', requireSignIn, async (req: AuthenticatedRequest, r
 
     if (targetUrl) {
       const updatedWorkflow = [...robot.recording.workflow];
-      
+
       for (let i = updatedWorkflow.length - 1; i >= 0; i--) {
         const step = updatedWorkflow[i];
         for (let j = 0; j < step.what.length; j++) {
@@ -286,7 +286,7 @@ router.put('/recordings/:id', requireSignIn, async (req: AuthenticatedRequest, r
             if (step.where?.url && step.where.url !== "about:blank") {
               step.where.url = targetUrl;
             }
-            
+
             robot.set('recording', { ...robot.recording, workflow: updatedWorkflow });
             robot.changed('recording', true);
             i = -1;
@@ -307,16 +307,16 @@ router.put('/recordings/:id', requireSignIn, async (req: AuthenticatedRequest, r
     if (limits && Array.isArray(limits) && limits.length > 0) {
       for (const limitInfo of limits) {
         const { pairIndex, actionIndex, argIndex, limit } = limitInfo;
-        
+
         const pair = workflow[pairIndex];
         if (!pair || !pair.what) continue;
-        
+
         const action = pair.what[actionIndex];
         if (!action || !action.args) continue;
-        
+
         const arg = action.args[argIndex];
         if (!arg || typeof arg !== 'object') continue;
-        
+
         (arg as { limit: number }).limit = limit;
       }
     }
@@ -384,7 +384,7 @@ router.post('/recordings/:id/duplicate', requireSignIn, async (req: Authenticate
 
       step.what.forEach((action) => {
         if (action.action === "goto" && action.args?.length) {
-          action.args[0] = targetUrl; 
+          action.args[0] = targetUrl;
         }
       });
 
@@ -394,22 +394,22 @@ router.post('/recordings/:id/duplicate', requireSignIn, async (req: Authenticate
     const currentTimestamp = new Date().toLocaleString();
 
     const newRobot = await Robot.create({
-      id: uuid(), 
-      userId: originalRobot.userId, 
+      id: uuid(),
+      userId: originalRobot.userId,
       recording_meta: {
         ...originalRobot.recording_meta,
         id: uuid(),
         name: `${originalRobot.recording_meta.name} (${lastWord})`,
-        createdAt: currentTimestamp, 
-        updatedAt: currentTimestamp, 
-      }, 
-      recording: { ...originalRobot.recording, workflow }, 
-      google_sheet_email: null, 
+        createdAt: currentTimestamp,
+        updatedAt: currentTimestamp,
+      },
+      recording: { ...originalRobot.recording, workflow },
+      google_sheet_email: null,
       google_sheet_name: null,
       google_sheet_id: null,
       google_access_token: null,
       google_refresh_token: null,
-      schedule: null, 
+      schedule: null,
     });
 
     logger.log('info', `Robot with ID ${id} duplicated successfully as ${newRobot.id}.`);
@@ -534,11 +534,11 @@ router.put('/runs/:id', requireSignIn, async (req: AuthenticatedRequest, res) =>
 
     // Generate runId first
     const runId = uuid();
-    
+
     // Check if user has reached browser limit
     const userBrowserIds = browserPool.getAllBrowserIdsForUser(req.user.id);
     const canCreateBrowser = userBrowserIds.length < 2;
-    
+
     if (canCreateBrowser) {
       // User has available browser slots, create it directly
       const id = createRemoteBrowserForRun(req.user.id);
@@ -572,7 +572,7 @@ router.put('/runs/:id', requireSignIn, async (req: AuthenticatedRequest, res) =>
 
       if (browserId) {
         // User has reached the browser limit, queue the run
-        try {        
+        try {
           // Create the run record with 'queued' status
           await Run.create({
             status: 'queued',
@@ -589,7 +589,7 @@ router.put('/runs/:id', requireSignIn, async (req: AuthenticatedRequest, res) =>
             serializableOutput: {},
             binaryOutput: {},
           });
-          
+
           return res.send({
             browserId: browserId,
             runId: runId,
@@ -664,17 +664,17 @@ router.post('/runs/run/:id', requireSignIn, async (req: AuthenticatedRequest, re
 
       // Queue the execution job
       await pgBoss.createQueue(userQueueName);
-      
+
       const jobId = await pgBoss.send(userQueueName, {
         userId: req.user.id,
         runId: req.params.id,
         browserId: plainRun.browserId
       });
-      
+
       logger.log('info', `Queued run execution job with ID: ${jobId} for run: ${req.params.id}`);
     } catch (queueError: any) {
       logger.log('error', `Failed to queue run execution`);
-      
+
     }
   } catch (e) {
     const { message } = e as Error;
@@ -889,15 +889,15 @@ router.delete('/schedule/:id', requireSignIn, async (req: AuthenticatedRequest,
  */
 router.post('/runs/abort/:id', requireSignIn, async (req: AuthenticatedRequest, res) => {
   try {
-    if (!req.user) { 
-      return res.status(401).send({ error: 'Unauthorized' }); 
+    if (!req.user) {
+      return res.status(401).send({ error: 'Unauthorized' });
     }
 
-    const run = await Run.findOne({ 
-      where: { 
+    const run = await Run.findOne({
+      where: {
         runId: req.params.id,
         runByUserId: req.user.id,
-      } 
+      }
     });
 
     if (!run) {
@@ -905,8 +905,8 @@ router.post('/runs/abort/:id', requireSignIn, async (req: AuthenticatedRequest,
     }
 
     if (!['running', 'queued'].includes(run.status)) {
-      return res.status(400).send({ 
-        error: `Cannot abort run with status: ${run.status}` 
+      return res.status(400).send({
+        error: `Cannot abort run with status: ${run.status}`
       });
     }
 
@@ -920,13 +920,13 @@ router.post('/runs/abort/:id', requireSignIn, async (req: AuthenticatedRequest,
         finishedAt: new Date().toLocaleString(),
         log: 'Run aborted while queued'
       });
-      
+
       return res.send({ success: true, message: 'Queued run aborted' });
     }
 
     const userQueueName = `abort-run-user-${req.user.id}`;
     await pgBoss.createQueue(userQueueName);
-    
+
     const jobId = await pgBoss.send(userQueueName, {
       userId: req.user.id,
       runId: req.params.id
@@ -934,10 +934,10 @@ router.post('/runs/abort/:id', requireSignIn, async (req: AuthenticatedRequest,
 
     logger.log('info', `Abort signal sent for run ${req.params.id}, job ID: ${jobId}`);
 
-    return res.send({ 
-      success: true, 
+    return res.send({
+      success: true,
       message: 'Abort signal sent',
-      jobId 
+      jobId
     });
 
   } catch (e) {