mx-cloud 0.0.18 → 0.0.19

package/build/interpret.d.ts

@@ -59,6 +59,9 @@ export default class Interpreter extends EventEmitter {
     private blocker;
     private cumulativeResults;
     private autohealFailures;
+    private namedResults;
+    private screenshotCounter;
+    private serializableDataByType;
     constructor(workflow: WorkflowFile, options?: Partial<InterpreterOptions>);
     trackAutohealFailure(error: string): void;
     private applyAdBlocker;

package/build/interpret.js

@@ -67,6 +67,12 @@ class Interpreter extends events_1.EventEmitter {
         this.blocker = null;
         this.cumulativeResults = [];
         this.autohealFailures = [];
+        this.namedResults = {};
+        this.screenshotCounter = 0;
+        this.serializableDataByType = {
+            scrapeList: {},
+            scrapeSchema: {}
+        };
         this.workflow = workflow.workflow;
         this.initializedWorkflow = null;
         this.options = Object.assign({ maxRepeats: 5, maxConcurrency: 5, serializableCallback: (data) => {
@@ -348,13 +354,22 @@ class Interpreter extends events_1.EventEmitter {
              * Beware of false linter errors - here, we know better!
              */
             const wawActions = {
-                screenshot: (params) => __awaiter(this, void 0, void 0, function* () {
+                screenshot: (params, nameOverride) => __awaiter(this, void 0, void 0, function* () {
                     var _a;
                     if ((_a = this.options.debugChannel) === null || _a === void 0 ? void 0 : _a.setActionType) {
-                        this.options.debugChannel.setActionType('screenshot');
+                        this.options.debugChannel.setActionType("screenshot");
                     }
                     const screenshotBuffer = yield page.screenshot(Object.assign(Object.assign({}, params), { path: undefined }));
-                    yield this.options.binaryCallback(screenshotBuffer, 'image/png');
+                    const baseName = nameOverride || "Screenshot";
+                    // ✅ Use the typed class property
+                    this.screenshotCounter += 1;
+                    const screenshotName = `${baseName} ${this.screenshotCounter}`;
+                    // ✅ Pass structured metadata to binaryCallback
+                    yield this.options.binaryCallback({
+                        name: screenshotName,
+                        data: screenshotBuffer,
+                        mimeType: "image/png",
+                    }, "image/png");
                 }),
                 enqueueLinks: (selector) => __awaiter(this, void 0, void 0, function* () {
                     var _a;
@@ -450,7 +465,31 @@ class Interpreter extends events_1.EventEmitter {
                     }
                     console.log("Total accumulated rows:", this.cumulativeResults.length);
                     console.log("Current results:", this.cumulativeResults);
-                    yield this.options.serializableCallback(this.cumulativeResults);
+                    // ✅ Append schema results under "scrapeSchema" → name
+                    const actionType = "scrapeSchema";
+                    const actionName = schema.__name || "Texts";
+                    if (!this.namedResults[actionType])
+                        this.namedResults[actionType] = {};
+                    this.namedResults[actionType][actionName] = this.cumulativeResults;
+                    if (!this.serializableDataByType[actionType])
+                        this.serializableDataByType[actionType] = {};
+                    if (!this.serializableDataByType[actionType])
+                        this.serializableDataByType[actionType] = {};
+                    if (!this.serializableDataByType[actionType][actionName]) {
+                        this.serializableDataByType[actionType][actionName] = {};
+                    }
+                    for (const row of this.cumulativeResults) {
+                        for (const [key, value] of Object.entries(row)) {
+                            if (value !== undefined) {
+                                this.serializableDataByType[actionType][actionName][key] = value;
+                            }
+                        }
+                    }
+                    // now emit full structured object
+                    yield this.options.serializableCallback({
+                        scrapeList: this.serializableDataByType.scrapeList,
+                        scrapeSchema: this.serializableDataByType.scrapeSchema
+                    });
                 }),
                 scrapeList: (config) => __awaiter(this, void 0, void 0, function* () {
                     var _a, _b;
@@ -491,12 +530,29 @@ class Interpreter extends events_1.EventEmitter {
                             scrapeResults = [];
                         }
                         console.log(`ScrapeList completed with ${scrapeResults.length} results`);
-                        yield this.options.serializableCallback(scrapeResults);
+                        // ✅ Append list results under "scrapeList" → name
+                        const actionType = "scrapeList";
+                        const actionName = config.__name || "List";
+                        if (!this.serializableDataByType[actionType])
+                            this.serializableDataByType[actionType] = {};
+                        if (!this.serializableDataByType[actionType][actionName]) {
+                            this.serializableDataByType[actionType][actionName] = [];
+                        }
+                        this.serializableDataByType[actionType][actionName].push(...scrapeResults);
+                        yield this.options.serializableCallback({
+                            scrapeList: this.serializableDataByType.scrapeList,
+                            scrapeSchema: this.serializableDataByType.scrapeSchema
+                        });
                     }
                     catch (error) {
                         console.error('ScrapeList action failed completely:', error.message);
                         // Don't throw error, just return empty array
-                        yield this.options.serializableCallback([]);
+                        const actionType = "scrapeList";
+                        const actionName = config.__name || "List";
+                        if (!this.namedResults[actionType])
+                            this.namedResults[actionType] = {};
+                        this.namedResults[actionType][actionName] = [];
+                        yield this.options.serializableCallback(this.namedResults);
                     }
                 }),
                 scrapeListAuto: (config) => __awaiter(this, void 0, void 0, function* () {
@@ -569,6 +625,41 @@ class Interpreter extends events_1.EventEmitter {
                     return;
                 }
                 this.log(`Launching ${String(step.action)}`, logger_1.Level.LOG);
+                try {
+                    const debug = this.options.debugChannel;
+                    if (debug === null || debug === void 0 ? void 0 : debug.setActionType) {
+                        debug.setActionType(String(step.action));
+                    }
+                    // Safely extract name for this step
+                    let stepName = null;
+                    // If the workflow step itself has a name
+                    if (step === null || step === void 0 ? void 0 : step.name) {
+                        stepName = step.name;
+                    }
+                    // If the first arg is an object with a __name property
+                    else if (Array.isArray(step === null || step === void 0 ? void 0 : step.args) &&
+                        step.args.length > 0 &&
+                        typeof step.args[0] === "object" &&
+                        "__name" in step.args[0]) {
+                        stepName = step.args[0].__name;
+                    }
+                    // If args itself is an object with a __name property
+                    else if (typeof (step === null || step === void 0 ? void 0 : step.args) === "object" &&
+                        (step === null || step === void 0 ? void 0 : step.args) !== null &&
+                        "__name" in step.args) {
+                        stepName = step.args.__name;
+                    }
+                    // Default fallback
+                    if (!stepName) {
+                        stepName = String(step.action);
+                    }
+                    if (debug && typeof debug.setActionName === "function") {
+                        debug.setActionName(stepName);
+                    }
+                }
+                catch (err) {
+                    this.log(`Failed to set action name/type: ${err.message}`, logger_1.Level.WARN);
+                }
                 try {
                     if (step.action in wawActions) {
                         // "Arrayifying" here should not be needed (TS + syntax checker - only arrays; but why not)

package/build/preprocessor.js

@@ -34,6 +34,8 @@ class Preprocessor {
                 what: joi_1.default.array().items({
                     action: joi_1.default.string().required(),
                     args: joi_1.default.array().items(joi_1.default.any()),
+                    name: joi_1.default.string(),
+                    actionId: joi_1.default.string()
                 }).required(),
             })).required(),
         });

package/build/types/workflow.d.ts

@@ -27,6 +27,8 @@ export type CustomFunctions = 'scrape' | 'scrapeSchema' | 'scroll' | 'screenshot
 export type What = {
     action: MethodNames<Page> | CustomFunctions;
     args?: any[];
+    name?: string;
+    actionId?: string;
 };
 export type PageState = Partial<BaseConditions>;
 export type ParamType = Record<string, any>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mx-cloud",
-  "version": "0.0.18",
+  "version": "0.0.19",
   "description": "mx cloud",
   "main": "build/index.js",
   "typings": "build/index.d.ts",