fix: resolved merge conflict

server/src/routes/storage.ts

@@ -112,6 +112,165 @@ function formatRunResponse(run: any) {
   return formattedRun;
 }
 
+/**
+ * PUT endpoint to update the name and limit of a robot.
+ */
+router.put('/recordings/:id', requireSignIn, async (req: AuthenticatedRequest, res) => {
+  try {
+    const { id } = req.params;
+    const { name, limit } = req.body;
+
+    // Validate input
+    if (!name && limit === undefined) {
+      return res.status(400).json({ error: 'Either "name" or "limit" must be provided.' });
+    }
+
+    // Fetch the robot by ID
+    const robot = await Robot.findOne({ where: { 'recording_meta.id': id } });
+
+    if (!robot) {
+      return res.status(404).json({ error: 'Robot not found.' });
+    }
+
+    // Update fields if provided
+    if (name) {
+      robot.set('recording_meta', { ...robot.recording_meta, name });
+    }
+
+    // Update the limit
+    if (limit !== undefined) {
+      const workflow = [...robot.recording.workflow]; // Create a copy of the workflow
+
+      // Ensure the workflow structure is valid before updating
+      if (
+        workflow.length > 0 &&
+        workflow[0]?.what?.[0]
+      ) {
+        // Create a new workflow object with the updated limit
+        const updatedWorkflow = workflow.map((step, index) => {
+          if (index === 0) { // Assuming you want to update the first step
+            return {
+              ...step,
+              what: step.what.map((action, actionIndex) => {
+                if (actionIndex === 0) { // Assuming the first action needs updating
+                  return {
+                    ...action,
+                    args: (action.args ?? []).map((arg, argIndex) => {
+                      if (argIndex === 0) { // Assuming the first argument needs updating
+                        return { ...arg, limit };
+                      }
+                      return arg;
+                    }),
+                  };
+                }
+                return action;
+              }),
+            };
+          }
+          return step;
+        });
+
+        // Replace the workflow in the recording object
+        robot.set('recording', { ...robot.recording, workflow: updatedWorkflow });
+      } else {
+        return res.status(400).json({ error: 'Invalid workflow structure for updating limit.' });
+      }
+    }
+
+    await robot.save();
+
+    const updatedRobot = await Robot.findOne({ where: { 'recording_meta.id': id } });
+    console.log('After save:', updatedRobot);
+
+    // Log the update
+    logger.log('info', `Robot with ID ${id} was updated successfully.`);
+
+    return res.status(200).json({ message: 'Robot updated successfully', robot });
+  } catch (error) {
+    // Safely handle the error type
+    if (error instanceof Error) {
+      logger.log('error', `Error updating robot with ID ${req.params.id}: ${error.message}`);
+      return res.status(500).json({ error: error.message });
+    } else {
+      logger.log('error', `Unknown error updating robot with ID ${req.params.id}`);
+      return res.status(500).json({ error: 'An unknown error occurred.' });
+    }
+  }
+});
+
+
+/**
+ * POST endpoint to duplicate a robot and update its target URL.
+ */
+router.post('/recordings/:id/duplicate', requireSignIn, async (req: AuthenticatedRequest, res) => {
+  try {
+    const { id } = req.params;
+    const { targetUrl } = req.body;
+
+    if (!targetUrl) {
+      return res.status(400).json({ error: 'The "targetUrl" field is required.' });
+    }
+
+    const originalRobot = await Robot.findOne({ where: { 'recording_meta.id': id } });
+
+    if (!originalRobot) {
+      return res.status(404).json({ error: 'Original robot not found.' });
+    }
+
+    const lastWord = targetUrl.split('/').filter(Boolean).pop() || 'Unnamed';
+
+    const workflow = originalRobot.recording.workflow.map((step) => {
+      if (step.where?.url && step.where.url !== "about:blank") {
+        step.where.url = targetUrl;
+      }
+
+      step.what.forEach((action) => {
+        if (action.action === "goto" && action.args?.length) {
+          action.args[0] = targetUrl; 
+        }
+      });
+
+      return step;
+    });
+
+    const currentTimestamp = new Date().toISOString();
+
+    const newRobot = await Robot.create({
+      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, 
+      google_sheet_name: null,
+      google_sheet_id: null,
+      google_access_token: null,
+      google_refresh_token: null,
+      schedule: null, 
+    });
+
+    logger.log('info', `Robot with ID ${id} duplicated successfully as ${newRobot.id}.`);
+
+    return res.status(201).json({
+      message: 'Robot duplicated and target URL updated successfully.',
+      robot: newRobot,
+    });
+  } catch (error) {
+    if (error instanceof Error) {
+      logger.log('error', `Error duplicating robot with ID ${req.params.id}: ${error.message}`);
+      return res.status(500).json({ error: error.message });
+    } else {
+      logger.log('error', `Unknown error duplicating robot with ID ${req.params.id}`);
+      return res.status(500).json({ error: 'An unknown error occurred.' });
+    }
+  }
+});
+
 /**
  * DELETE endpoint for deleting a recording from the storage.
  */