testdriverai 7.1.4 → 7.2.0

package/agent/lib/commands.js

@@ -114,6 +114,7 @@ const createCommands = (
   const niceSeconds = (ms) => {
     return Math.round(ms / 1000);
   };
+  
   const delay = (t) => new Promise((resolve) => setTimeout(resolve, t));
 
   const findImageOnScreen = async (
@@ -214,12 +215,15 @@ const createCommands = (
   };
 
   const assert = async (assertion, shouldThrow = false) => {
+    let assertStartTimeForHandler;
     const handleAssertResponse = (response) => {
-      emitter.emit(events.log.log, response);
-
-      let valid = response.indexOf("The task passed") > -1;
+      const { formatter } = require("../../sdk-log-formatter.js");
+      const passed = response.indexOf("The task passed") > -1;
+      const duration = assertStartTimeForHandler ? Date.now() - assertStartTimeForHandler : undefined;
+      
+      emitter.emit(events.log.narration, formatter.formatAssertResult(passed, response, duration), true);
 
-      if (valid) {
+      if (passed) {
         return true;
       } else {
         if (shouldThrow) {
@@ -237,9 +241,12 @@ const createCommands = (
     const assertingMessage = formatter.formatAsserting(assertion);
     emitter.emit(events.log.log, assertingMessage);
 
-    emitter.emit(events.log.narration, `thinking...`);
-
-    const assertStartTime = Date.now();
+    // Capture absolute timestamp at the very start of the command
+    // Frontend will calculate relative time using: timestamp - replay.clientStartDate
+    const assertTimestamp = Date.now();
+    const assertStartTime = assertTimestamp;
+    assertStartTimeForHandler = assertStartTime;
+    
     let response = await sdk.req("assert", {
       expect: assertion,
       image: await system.captureScreenBase64(),
@@ -258,7 +265,7 @@ const createCommands = (
           interactionType: "assert",
           session: sessionId,
           prompt: assertion,
-          timestamp: assertStartTime,
+          timestamp: assertTimestamp, // Absolute epoch timestamp - frontend calculates relative using clientStartDate
           duration: assertDuration,
           success: assertionPassed,
           error: assertionPassed ? undefined : response.data,
@@ -283,6 +290,10 @@ const createCommands = (
    * @param {number} [options.redraw.diffThreshold=0.1] - Screen diff threshold percentage
    */
   const scroll = async (direction = 'down', options = {}) => {
+    // Capture absolute timestamp at the very start of the command
+    // Frontend will calculate relative time using: timestamp - replay.clientStartDate
+    const scrollTimestamp = Date.now();
+    const scrollStartTime = scrollTimestamp;
     // Convert number to object format
     if (typeof options === 'number') {
       options = { amount: options };
@@ -290,50 +301,121 @@ const createCommands = (
     
     let { amount = 300 } = options;
     const redrawOptions = extractRedrawOptions(options);
-    
-    emitter.emit(
-      events.log.narration,
-      theme.dim(`scrolling ${direction} ${amount}px...`),
-    );
 
     await redraw.start(redrawOptions);
 
     amount = parseInt(amount, 10);
 
     const before = await system.captureScreenBase64();
-    switch (direction) {
-      case "up":
-        await sandbox.send({
-          type: "scroll",
-          amount,
-          direction,
-        });
-        await redraw.wait(2500, redrawOptions);
-        break;
-      case "down":
-        await sandbox.send({
-          type: "scroll",
-          amount,
-          direction,
-        });
-        await redraw.wait(2500, redrawOptions);
-        break;
-      case "left":
-        console.error("Not Supported");
-        break;
-      case "right":
-        console.error("Not Supported");
-        break;
-      default:
-        throw new CommandError("Direction not found");
-    }
-    const after = await system.captureScreenBase64();
+    let scrollSuccess = true;
+    let scrollError;
+    let actionEndTime;
+    
+    try {
+      switch (direction) {
+        case "up":
+          await sandbox.send({
+            type: "scroll",
+            amount,
+            direction,
+          });
+          actionEndTime = Date.now();
+          break;
+        case "down":
+          await sandbox.send({
+            type: "scroll",
+            amount,
+            direction,
+          });
+          actionEndTime = Date.now();
+          break;
+        case "left":
+          console.error("Not Supported");
+          scrollSuccess = false;
+          scrollError = "Left scroll not supported";
+          break;
+        case "right":
+          console.error("Not Supported");
+          scrollSuccess = false;
+          scrollError = "Right scroll not supported";
+          break;
+        default:
+          scrollSuccess = false;
+          scrollError = "Direction not found";
+          throw new CommandError("Direction not found");
+      }
+      
+      const actionDuration = actionEndTime ? actionEndTime - scrollStartTime : Date.now() - scrollStartTime;
+      
+      // Log nested scroll action completion
+      const { formatter } = require("../../sdk-log-formatter.js");
+      emitter.emit(
+        events.log.narration,
+        formatter.formatScrollResult(direction, amount, actionDuration),
+        true,
+      );
+      
+      // Wait for redraw and track duration
+      const redrawStartTime = Date.now();
+      await redraw.wait(2500, redrawOptions);
+      const redrawDuration = Date.now() - redrawStartTime;
+      
+      const after = await system.captureScreenBase64();
 
-    if (before === after) {
+      if (before === after) {
+        emitter.emit(
+          events.log.warn,
+          "Attempted to scroll, but the screen did not change.  You may need to click a non-interactive element to focus the scrollable area first.",
+        );
+      }
+      
+      // Log nested redraw completion
       emitter.emit(
-        events.log.warn,
-        "Attempted to scroll, but the screen did not change.  You may need to click a non-interactive element to focus the scrollable area first.",
+        events.log.narration,
+        formatter.formatRedrawComplete(redrawDuration),
+        true,
       );
+      
+      // Track interaction success
+      const sessionId = sessionInstance?.get();
+      if (sessionId) {
+        try {
+          const scrollDuration = Date.now() - scrollStartTime;
+          await sandbox.send({
+            type: "trackInteraction",
+            interactionType: "scroll",
+            session: sessionId,
+            input: { direction, amount },
+            timestamp: scrollTimestamp, // Absolute epoch timestamp - frontend calculates relative using clientStartDate
+            duration: scrollDuration,
+            success: scrollSuccess,
+            error: scrollError,
+          });
+        } catch (err) {
+          console.warn("Failed to track scroll interaction:", err.message);
+        }
+      }
+    } catch (error) {
+      // Track interaction failure
+      const sessionId = sessionInstance?.get();
+      if (sessionId) {
+        try {
+          const scrollDuration = Date.now() - scrollStartTime;
+          await sandbox.send({
+            type: "trackInteraction",
+            interactionType: "scroll",
+            session: sessionId,
+            input: { direction, amount },
+            timestamp: scrollTimestamp, // Absolute epoch timestamp - frontend calculates relative using clientStartDate
+            duration: scrollDuration,
+            success: false,
+            error: error.message,
+          });
+        } catch (err) {
+          console.warn("Failed to track scroll interaction:", err.message);
+        }
+      }
+      throw error;
     }
   };
 
@@ -354,7 +436,10 @@ const createCommands = (
    * @param {number} [options.redraw.diffThreshold=0.1] - Screen diff threshold percentage
    */
   const click = async (...args) => {
-    const clickStartTime = Date.now();
+    // Capture absolute timestamp at the very start of the command
+    // Frontend will calculate relative time using: timestamp - replay.clientStartDate
+    const clickTimestamp = Date.now();
+    const clickStartTime = clickTimestamp;
     let x, y, action, elementData, redrawOptions;
     
     // Handle both object and positional argument styles
@@ -384,37 +469,35 @@ const createCommands = (
         double = true;
       }
 
-      emitter.emit(
-        events.log.narration,
-        theme.dim(`${action} ${button} clicking at ${x}, ${y}...`),
-        true,
-      );
+      // Show nested action details
+      const actionText = action.split("-").join("");
+      const clickActionLogStart = Date.now();
 
       x = parseInt(x);
       y = parseInt(y);
 
-      // Add dashcam timestamp if available
-      if (getDashcamElapsedTime) {
-        const elapsed = getDashcamElapsedTime();
-        if (elapsed !== null) {
-          elementData.timestamp = elapsed;
-        }
-      }
+      // Add absolute timestamp for sandbox events
+      elementData.timestamp = Date.now();
 
       await sandbox.send({ type: "moveMouse", x, y, ...elementData });
 
       emitter.emit(events.mouseMove, { x, y });
 
       await delay(2500); // wait for the mouse to move
+      
+      // Update the action log with duration
+      const clickMoveEndTime = Date.now();
+      const { formatter } = require("../../sdk-log-formatter.js");
+      emitter.emit(
+        events.log.narration,
+        formatter.formatClickResult(button, x, y, clickMoveEndTime - clickActionLogStart),
+        true,
+      );
 
       if (action !== "hover") {
         // Update timestamp for the actual click action
-        if (getDashcamElapsedTime) {
-          const elapsed = getDashcamElapsedTime();
-          if (elapsed !== null) {
-            elementData.timestamp = elapsed;
-          }
-        }
+        elementData.timestamp = Date.now();
+        
 
         if (action === "click" || action === "left-click") {
           await sandbox.send({ type: "leftClick", x, y, ...elementData });
@@ -438,19 +521,22 @@ const createCommands = (
 
         emitter.emit(events.mouseClick, { x, y, button, click, double });
         
+        // Track action duration (before redraw wait)
+        const actionEndTime = Date.now();
+        const actionDuration = actionEndTime - clickStartTime;
+        
         // Track interaction
         const sessionId = sessionInstance?.get();
         if (sessionId && elementData.prompt) {
           try {
-            const clickDuration = Date.now() - clickStartTime;
             await sandbox.send({
               type: "trackInteraction",
               interactionType: "click",
               session: sessionId,
               prompt: elementData.prompt,
               input: { x, y, action },
-              timestamp: clickStartTime,
-              duration: clickDuration,
+              timestamp: clickTimestamp, // Absolute epoch timestamp - frontend calculates relative using clientStartDate
+              duration: actionDuration,
               success: true,
               cacheHit: elementData.cacheHit,
               selector: elementData.selector,
@@ -460,10 +546,33 @@ const createCommands = (
             console.warn("Failed to track click interaction:", err.message);
           }
         }
+        
+        // Wait for redraw and track duration
+        const redrawStartTime = Date.now();
+        await redraw.wait(5000, redrawOptions);
+        const redrawDuration = Date.now() - redrawStartTime;
+        
+        // Log nested redraw completion
+        emitter.emit(
+          events.log.narration,
+          formatter.formatRedrawComplete(redrawDuration),
+          true,
+        );
+      } else {
+        // For hover action (within click function)
+        const redrawStartTime = Date.now();
+        await redraw.wait(5000, redrawOptions);
+        const redrawDuration = Date.now() - redrawStartTime;
+        const actionDuration = Date.now() - clickStartTime - redrawDuration;
+        
+        // Log nested redraw completion
+        emitter.emit(
+          events.log.narration,
+          formatter.formatRedrawComplete(redrawDuration),
+          true,
+        );
       }
 
-      await redraw.wait(5000, redrawOptions);
-
       return;
     } catch (error) {
       // Track interaction failure
@@ -477,7 +586,7 @@ const createCommands = (
             session: sessionId,
             prompt: elementData.prompt,
             input: { x, y, action },
-            timestamp: clickStartTime,
+            timestamp: clickTimestamp, // Absolute epoch timestamp - frontend calculates relative using clientStartDate
             duration: clickDuration,
             success: false,
             error: error.message,
@@ -504,7 +613,10 @@ const createCommands = (
    * @param {boolean} [options.selectorUsed] - Whether selector was used
    */
   const hover = async (...args) => {
-    const hoverStartTime = Date.now();
+    // Capture absolute timestamp at the very start of the command
+    // Frontend will calculate relative time using: timestamp - replay.clientStartDate
+    const hoverTimestamp = Date.now();
+    const hoverStartTime = hoverTimestamp;
     let x, y, elementData, redrawOptions;
     
     // Handle both object and positional argument styles
@@ -528,29 +640,26 @@ const createCommands = (
       x = parseInt(x);
       y = parseInt(y);
 
-      // Add dashcam timestamp if available
-      if (getDashcamElapsedTime) {
-        const elapsed = getDashcamElapsedTime();
-        if (elapsed !== null) {
-          elementData.timestamp = elapsed;
-        }
-      }
+      // Add absolute timestamp for sandbox events
+      elementData.timestamp = Date.now();
 
       await sandbox.send({ type: "moveMouse", x, y, ...elementData });
 
       // Track interaction
       const sessionId = sessionInstance?.get();
+      const actionEndTime = Date.now();
+      const actionDuration = actionEndTime - hoverStartTime;
+      
       if (sessionId && elementData.prompt) {
         try {
-          const hoverDuration = Date.now() - hoverStartTime;
           await sandbox.send({
             type: "trackInteraction",
             interactionType: "hover",
             session: sessionId,
             prompt: elementData.prompt,
             input: { x, y },
-            timestamp: hoverStartTime,
-            duration: hoverDuration,
+            timestamp: hoverTimestamp, // Absolute epoch timestamp - frontend calculates relative using clientStartDate
+            duration: actionDuration,
             success: true,
             cacheHit: elementData.cacheHit,
             selector: elementData.selector,
@@ -561,7 +670,19 @@ const createCommands = (
         }
       }
 
+      // Wait for redraw and track duration
+      const redrawStartTime = Date.now();
       await redraw.wait(2500, redrawOptions);
+      const redrawDuration = Date.now() - redrawStartTime;
+      
+      // Log action completion with separate durations
+      const { formatter } = require("../../sdk-log-formatter.js");
+      const completionMessage = formatter.formatActionComplete("hover", elementData.prompt, {
+        actionDuration,
+        redrawDuration,
+        cacheHit: elementData.cacheHit,
+      });
+      emitter.emit(events.log.log, completionMessage);
 
       return;
     } catch (error) {
@@ -576,7 +697,7 @@ const createCommands = (
             session: sessionId,
             prompt: elementData.prompt,
             input: { x, y },
-            timestamp: hoverStartTime,
+            timestamp: hoverTimestamp, // Absolute epoch timestamp - frontend calculates relative using clientStartDate
             duration: hoverDuration,
             success: false,
             error: error.message,
@@ -754,32 +875,35 @@ const createCommands = (
      * @param {number} [options.redraw.diffThreshold=0.1] - Screen diff threshold percentage
      */
     "type": async (text, options = {}) => {
-      const typeStartTime = Date.now();
+      const { formatter } = require("../../sdk-log-formatter.js");
+      // Capture absolute timestamp at the very start of the command
+      // Frontend will calculate relative time using: timestamp - replay.clientStartDate
+      const typeTimestamp = Date.now();
+      const typeStartTime = typeTimestamp;
       const { delay = 250, secret = false, redraw: redrawOpts, ...elementData } = options;
       const redrawOptions = extractRedrawOptions({ redraw: redrawOpts, ...options });
       
-      // Log masked version if secret, otherwise show actual text
+      // Log parent action with text
       if (secret) {
-        emitter.emit(events.log.narration, theme.dim(`typing secret "****"...`));
+        emitter.emit(events.log.narration, formatter.getPrefix("type") + " " + theme.yellow.bold("Type") + " " + theme.dim(`secret "****"`));
       } else {
-        emitter.emit(events.log.narration, theme.dim(`typing "${text}"...`));
+        emitter.emit(events.log.narration, formatter.getPrefix("type") + " " + theme.yellow.bold("Type") + " " + theme.cyan(`"${text}"`));
       }
 
       await redraw.start(redrawOptions);
 
       text = text.toString();
 
-      // Add dashcam timestamp if available
-      if (getDashcamElapsedTime) {
-        const elapsed = getDashcamElapsedTime();
-        if (elapsed !== null) {
-          elementData.timestamp = elapsed;
-        }
-      }
+      // Add absolute timestamp for sandbox events
+      elementData.timestamp = Date.now();
 
       // Actually type the text in the sandbox
       await sandbox.send({ type: "write", text, delay, ...elementData });
       
+      // Update the action log with duration
+      const typeActionEndTime = Date.now();
+      emitter.emit(events.log.narration, formatter.formatTypeResult(text, secret, typeActionEndTime - typeStartTime), true);
+      
       // Track interaction
       const sessionId = sessionInstance?.get();
       if (sessionId) {
@@ -791,7 +915,7 @@ const createCommands = (
             session: sessionId,
             // Store masked text if secret, otherwise store actual text
             input: { text: secret ? "****" : text, delay },
-            timestamp: typeStartTime,
+            timestamp: typeTimestamp, // Absolute epoch timestamp - frontend calculates relative using clientStartDate
             duration: typeDuration,
             success: true,
             isSecret: secret, // Flag this interaction if it contains a secret
@@ -801,7 +925,17 @@ const createCommands = (
         }
       }
       
+      const redrawStartTime = Date.now();
       await redraw.wait(5000, redrawOptions);
+      const redrawDuration = Date.now() - redrawStartTime;
+      
+      // Log nested redraw completion
+      emitter.emit(
+        events.log.narration,
+        formatter.formatRedrawComplete(redrawDuration),
+        true,
+      );
+      
       return;
     },
     /**
@@ -815,20 +949,36 @@ const createCommands = (
      * @param {number} [options.redraw.diffThreshold=0.1] - Screen diff threshold percentage
      */
     "press-keys": async (keys, options = {}) => {
-      const pressKeysStartTime = Date.now();
+      const { formatter } = require("../../sdk-log-formatter.js");
+      // Capture absolute timestamp at the very start of the command
+      // Frontend will calculate relative time using: timestamp - replay.clientStartDate
+      const pressKeysTimestamp = Date.now();
+      const pressKeysStartTime = pressKeysTimestamp;
       const redrawOptions = extractRedrawOptions(options);
+      const keysDisplay = Array.isArray(keys) ? keys.join(", ") : keys;
+      
+      // Log parent action
       emitter.emit(
         events.log.narration,
-        theme.dim(
-          `pressing keys: ${Array.isArray(keys) ? keys.join(", ") : keys}...`,
-        ),
+        formatter.getPrefix("pressKeys") + " " + theme.yellow.bold("PressKeys") + " " + theme.cyan(`${keysDisplay}`),
       );
 
       await redraw.start(redrawOptions);
 
+      // Log nested action details
+      const pressKeysActionLogStart = Date.now();
+
       // finally, press the keys
       await sandbox.send({ type: "press", keys });
       
+      // Update the action log with duration
+      const pressKeysActionEndTime = Date.now();
+      emitter.emit(
+        events.log.narration,
+        formatter.formatPressKeysResult(keysDisplay, pressKeysActionEndTime - pressKeysActionLogStart),
+        true,
+      );
+      
       // Track interaction
       const sessionId = sessionInstance?.get();
       if (sessionId) {
@@ -839,7 +989,7 @@ const createCommands = (
             interactionType: "pressKeys",
             session: sessionId,
             input: { keys },
-            timestamp: pressKeysStartTime,
+            timestamp: pressKeysTimestamp, // Absolute epoch timestamp - frontend calculates relative using clientStartDate
             duration: pressKeysDuration,
             success: true,
           });
@@ -848,7 +998,16 @@ const createCommands = (
         }
       }
 
+      const redrawStartTime = Date.now();
       await redraw.wait(5000, redrawOptions);
+      const redrawDuration = Date.now() - redrawStartTime;
+      
+      // Log nested redraw completion
+      emitter.emit(
+        events.log.narration,
+        formatter.formatRedrawComplete(redrawDuration),
+        true,
+      );
 
       return;
     },
@@ -858,7 +1017,10 @@ const createCommands = (
      * @param {Object} [options] - Additional options (reserved for future use)
      */
     "wait": async (timeout = 3000, options = {}) => {
-      const waitStartTime = Date.now();
+      // Capture absolute timestamp at the very start of the command
+      // Frontend will calculate relative time using: timestamp - replay.clientStartDate
+      const waitTimestamp = Date.now();
+      const waitStartTime = waitTimestamp;
       emitter.emit(events.log.narration, theme.dim(`waiting ${timeout}ms...`));
       const result = await delay(timeout);
       
@@ -872,7 +1034,7 @@ const createCommands = (
             interactionType: "wait",
             session: sessionId,
             input: { timeout },
-            timestamp: waitStartTime,
+            timestamp: waitTimestamp, // Use dashcam elapsed time instead of absolute time
             duration: waitDuration,
             success: true,
           });
@@ -890,6 +1052,9 @@ const createCommands = (
      * @param {number} [options.timeout=10000] - Timeout in milliseconds
      */
     "wait-for-image": async (...args) => {
+      // Capture absolute timestamp at the very start of the command
+      // Frontend will calculate relative time using: timestamp - replay.clientStartDate
+      const waitForImageTimestamp = Date.now();
       let description, timeout;
       
       // Handle both object and positional argument styles
@@ -951,7 +1116,7 @@ const createCommands = (
               session: sessionId,
               prompt: description,
               input: { timeout },
-              timestamp: startTime,
+              timestamp: waitForImageTimestamp, // Absolute epoch timestamp - frontend calculates relative using clientStartDate
               duration: waitForImageDuration,
               success: true,
             });
@@ -974,7 +1139,7 @@ const createCommands = (
               session: sessionId,
               prompt: description,
               input: { timeout },
-              timestamp: startTime,
+              timestamp: waitForImageTimestamp, // Absolute epoch timestamp - frontend calculates relative using clientStartDate
               duration: waitForImageDuration,
               success: false,
               error: errorMsg,
@@ -999,6 +1164,9 @@ const createCommands = (
      * @param {number} [options.redraw.diffThreshold=0.1] - Screen diff threshold percentage
      */
     "wait-for-text": async (...args) => {
+      // Capture absolute timestamp at the very start of the command
+      // Frontend will calculate relative time using: timestamp - replay.clientStartDate
+      const waitForTextTimestamp = Date.now();
       let text, timeout, redrawOptions;
       
       // Handle both object and positional argument styles
@@ -1061,7 +1229,7 @@ const createCommands = (
               session: sessionId,
               prompt: text,
               input: { timeout },
-              timestamp: startTime,
+              timestamp: waitForTextTimestamp, // Absolute epoch timestamp - frontend calculates relative using clientStartDate
               duration: waitForTextDuration,
               success: true,
             });
@@ -1084,7 +1252,7 @@ const createCommands = (
               session: sessionId,
               prompt: text,
               input: { timeout },
-              timestamp: startTime,
+              timestamp: waitForTextTimestamp, // Absolute epoch timestamp - frontend calculates relative using clientStartDate
               duration: waitForTextDuration,
               success: false,
               error: errorMsg,
@@ -1281,7 +1449,10 @@ const createCommands = (
      * @param {string} options.description - What to extract
      */
     "extract": async (...args) => {
-      const rememberStartTime = Date.now();
+      // Capture absolute timestamp at the very start of the command
+      // Frontend will calculate relative time using: timestamp - replay.clientStartDate
+      const rememberTimestamp = Date.now();
+      const rememberStartTime = rememberTimestamp;
       let description;
       
       // Handle both object and positional argument styles
@@ -1305,15 +1476,15 @@ const createCommands = (
             const rememberDuration = Date.now() - rememberStartTime;
             await sandbox.send({
               type: "trackInteraction",
-              interactionType: "remember",
+              interactionType: "extract",
               session: sessionId,
               prompt: description,
-              timestamp: rememberStartTime,
+              timestamp: rememberTimestamp, // Absolute epoch timestamp - frontend calculates relative using clientStartDate
               duration: rememberDuration,
               success: true,
             });
           } catch (err) {
-            console.warn("Failed to track remember interaction:", err.message);
+            console.warn("Failed to track extract interaction:", err.message);
           }
         }
         
@@ -1326,16 +1497,16 @@ const createCommands = (
             const rememberDuration = Date.now() - rememberStartTime;
             await sandbox.send({
               type: "trackInteraction",
-              interactionType: "remember",
+              interactionType: "extract",
               session: sessionId,
               prompt: description,
-              timestamp: rememberStartTime,
+              timestamp: rememberTimestamp, // Absolute epoch timestamp - frontend calculates relative using clientStartDate
               duration: rememberDuration,
               success: false,
               error: error.message,
             });
           } catch (err) {
-            console.warn("Failed to track remember interaction:", err.message);
+            console.warn("Failed to track extract interaction:", err.message);
           }
         }
         throw error;
@@ -1360,6 +1531,7 @@ const createCommands = (
      * @param {boolean} [options.silent=false] - Suppress output
      */
     "exec": async (...args) => {
+      const { formatter } = require("../../sdk-log-formatter.js");
       let language, code, timeout, silent;
       
       // Handle both object and positional argument styles
@@ -1370,9 +1542,13 @@ const createCommands = (
         [language = 'pwsh', code, timeout, silent = false] = args;
       }
       
-      emitter.emit(events.log.narration, theme.dim(`calling exec...`), true);
+      // Log parent action
+      emitter.emit(events.log.narration, formatter.getPrefix("action") + " " + theme.cyan.bold("Exec") + " " + theme.magenta(`[${language}]`), true);
 
-      emitter.emit(events.log.log, code);
+      // Log nested command details (truncate to first line)
+      const firstLine = code.split('\n')[0];
+      const codeDisplay = code.includes('\n') ? firstLine + '...' : firstLine;
+      emitter.emit(events.log.log, formatter.formatCodeLine(codeDisplay));
 
       let plat = system.platform();
 
@@ -1399,27 +1575,48 @@ const createCommands = (
           language = "pwsh";
         }
 
+        const execActionLogStart = Date.now();
+
         let result = null;
 
         result = await sandbox.send({
           type: "commands.run",
           command: code,
           timeout,
-        });
+        }, timeout || 300000);
+        
+        const execActionEndTime = Date.now();
+        const execDuration = execActionEndTime - execActionLogStart;
+
+        // const debugMode = process.env.VERBOSE || process.env.DEBUG || process.env.TD_DEBUG;
+        // if (debugMode) {
+        //   console.log(result);
+        // }
 
         if (result.out && result.out.returncode !== 0) {
+          emitter.emit(
+            events.log.narration,
+            formatter.formatExecComplete(result.out.returncode, execDuration),
+            true,
+          );
           throw new MatchError(
             `Command failed with exit code ${result.out.returncode}: ${result.out.stderr}`,
           );
         } else {
+          emitter.emit(
+            events.log.narration,
+            formatter.formatExecComplete(0, execDuration),
+            true,
+          );
+          
           if (!silent && result.out?.stdout) {
-            emitter.emit(events.log.log, theme.dim(`stdout:`), true);
-            emitter.emit(events.log.log, `${result.out.stdout}`, true);
+            emitter.emit(events.log.log, theme.dim(`  stdout:`), true);
+            emitter.emit(events.log.log, theme.dim(`  ${result.out.stdout}`), true);
           }
 
           if (!silent && result.out.stderr) {
-            emitter.emit(events.log.log, theme.dim(`stderr:`), true);
-            emitter.emit(events.log.log, `${result.out.stderr}`, true);
+            emitter.emit(events.log.log, theme.dim(`  stderr:`), true);
+            emitter.emit(events.log.log, theme.dim(`  ${result.out.stderr}`), true);
           }
 
           return result.out?.stdout?.trim();
@@ -1476,10 +1673,13 @@ const createCommands = (
         if (!stepResult) {
           emitter.emit(events.log.log, `No result returned from script`, true);
         } else {
-          if (!silent) {
-            emitter.emit(events.log.log, theme.dim(`Result:`), true);
-            emitter.emit(events.log.log, stepResult, true);
-          }
+        /* The above JavaScript code is checking if the variable `silent` is falsy (not true) and if
+        so, it emits log events using an emitter. The emitted log events include the
+        theme.dim(`Result:`) and the value of the `stepResult` variable. */
+          // if (!silent) {
+          //   emitter.emit(events.log.log, theme.dim(`Result:`), true);
+          //   emitter.emit(events.log.log, stepResult, true);
+          // }
         }
 
         return stepResult;