refactor(core): improve error messages in FileStorage and normalize task recorder fields in ExecutionDump

Author: quanru

packages/core/src/screenshot-item.ts

@@ -82,10 +82,11 @@ export class ScreenshotItem {
 
   /** Check if a value is a serialized ScreenshotItem */
   static isSerialized(value: unknown): value is { $screenshot: string } {
-    if (typeof value !== 'object' || value === null) {
-      return false;
-    }
-    const obj = value as Record<string, unknown>;
-    return '$screenshot' in obj && typeof obj.$screenshot === 'string';
+    return (
+      typeof value === 'object' &&
+      value !== null &&
+      '$screenshot' in value &&
+      typeof (value as Record<string, unknown>).$screenshot === 'string'
+    );
   }
 }

packages/core/src/storage/file.ts

@@ -68,10 +68,14 @@ export class FileStorage implements StorageProvider {
   async retrieve(id: string): Promise<string> {
     const filePath = this.registry.get(id);
     if (!filePath) {
-      throw new Error(`FileStorage: File not found for id: ${id}`);
+      throw new Error(
+        `FileStorage: Data not found for id: ${id} (not in registry)`,
+      );
     }
     if (!fs.existsSync(filePath)) {
-      throw new Error(`FileStorage: File does not exist: ${filePath}`);
+      throw new Error(
+        `FileStorage: Data not found for id: ${id} (file missing at: ${filePath})`,
+      );
     }
     return fs.readFileSync(filePath, 'utf-8');
   }

packages/core/src/types.ts

@@ -415,12 +415,31 @@ function reviverForDumpDeserialization(key: string, value: any): any {
   if (key === 'screenshot' && ScreenshotItem.isSerialized(value)) {
     // Use MemoryStorage as default provider for deserialization
     // The actual data will be loaded later via storageProvider
+    // Note: Import here to avoid circular dependency issues
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
     const { MemoryStorage } = require('./storage');
     return ScreenshotItem.restore(value.$screenshot, new MemoryStorage());
   }
   return value;
 }
 
+/**
+ * Helper to ensure all tasks have recorder field (even if empty)
+ */
+function normalizeTaskRecorder(
+  tasks: IExecutionDump['tasks'],
+): IExecutionDump['tasks'] {
+  return tasks.map((task: any) => ({
+    ...task,
+    recorder: task.recorder || [],
+  }));
+}
+
+/**
+ * Type for screenshot serialization result
+ */
+type SerializedScreenshot = { base64: string };
+
 /**
  * ExecutionDump class for serializing and deserializing execution dumps
  */
@@ -526,43 +545,37 @@ export class ExecutionDump implements IExecutionDump {
 
     // Use async processing for screenshots (inline or file path mode)
     if (inlineScreenshots || screenshotsPath) {
-      const collectScreenshotPromises = (obj: any): Promise<any> => {
+      const processValue = async (
+        obj: unknown,
+      ): Promise<
+        unknown | SerializedScreenshot | unknown[] | Record<string, unknown>
+      > => {
         if (obj instanceof ScreenshotItem) {
           if (screenshotsPath) {
             // Directory mode: return file path
-            return Promise.resolve({
-              base64: `${screenshotsPath}/${obj.id}.png`,
-            });
+            return { base64: `${screenshotsPath}/${obj.id}.png` };
           }
           // Inline mode: return base64 data
-          return obj.getData().then((base64) => ({ base64 }));
+          const base64 = await obj.getData();
+          return { base64 };
         }
         if (Array.isArray(obj)) {
-          return Promise.all(obj.map(collectScreenshotPromises));
+          return Promise.all(obj.map(processValue));
         }
         if (obj && typeof obj === 'object') {
-          const promises: Record<string, Promise<any>> = {};
-          for (const [key, value] of Object.entries(obj)) {
-            promises[key] = collectScreenshotPromises(value);
-          }
-          return (async () => {
-            const resolved: Record<string, any> = {};
-            for (const [key, promise] of Object.entries(promises)) {
-              resolved[key] = await promise;
-            }
-            return resolved;
-          })();
+          const entries = await Promise.all(
+            Object.entries(obj).map(async ([key, value]) => [
+              key,
+              await processValue(value),
+            ]),
+          );
+          return Object.fromEntries(entries);
         }
-        return Promise.resolve(obj);
+        return obj;
       };
 
-      const resolvedData = await collectScreenshotPromises(this.toJSON());
-      const result = resolvedData as IExecutionDump;
-      // Ensure all tasks have recorder field (even if empty)
-      result.tasks = result.tasks.map((task: any) => ({
-        ...task,
-        recorder: task.recorder || [],
-      }));
+      const result = (await processValue(this.toJSON())) as IExecutionDump;
+      result.tasks = normalizeTaskRecorder(result.tasks);
       return result;
     }
 
@@ -573,12 +586,8 @@ export class ExecutionDump implements IExecutionDump {
       }
       return value;
     });
-    const result = JSON.parse(jsonString);
-    // Ensure all tasks have recorder field (even if empty)
-    result.tasks = result.tasks.map((task: any) => ({
-      ...task,
-      recorder: task.recorder || [],
-    }));
+    const result = JSON.parse(jsonString) as IExecutionDump;
+    result.tasks = normalizeTaskRecorder(result.tasks);
     return result;
   }
 }

packages/core/tests/unit-test/execution-dump.test.ts

@@ -98,7 +98,7 @@ describe('ExecutionDump', () => {
   });
 
   describe('toJSON', () => {
-    it('should return a plain object', () => {
+    it('should return a plain object with recorder fields normalized', () => {
       const data = createMockExecutionDumpData();
       const dump = new ExecutionDump(data);
       const json = dump.toJSON();
@@ -107,7 +107,10 @@ describe('ExecutionDump', () => {
         logTime: data.logTime,
         name: data.name,
         description: data.description,
-        tasks: data.tasks,
+        tasks: data.tasks.map((task) => ({
+          ...task,
+          recorder: task.recorder || [],
+        })),
         aiActContext: data.aiActContext,
       });
     });

packages/web-integration/tests/ai/web/puppeteer/open-new-tab.test.ts

@@ -25,7 +25,7 @@ describe('agent with forceSameTabNavigation', () => {
     resetFn = reset;
     agent = new PuppeteerAgent(originPage, {
       cacheId: 'puppeteer-open-new-tab',
-      useDirectoryReport: true,
+      useDirectoryReport: false,
     });
     const inputXpath = '//*[@id="sb_form_q"]';
     await agent.aiInput('The search input box', {