@xuda.io/xuda-worker-bundle 1.3.2698 → 1.3.2700

package/index.js

@@ -5231,7 +5231,17 @@ func.datasource.run_events_functions = async function (SESSION_ID, dataSourceSes
                   resolve(job_num);
                 }
                 if (i > 200) {
-                  console.error('deadlock detected');
+                  func.utils.report_issue(SESSION_ID, {
+                    code: 'RUN_MSG_DSC_050',
+                    source: 'func.datasource.run_events_functions',
+                    message: 'deadlock detected',
+                    type: 'E',
+                    details: {
+                      job_num,
+                      event_id,
+                      dsSessionP,
+                    },
+                  });
                   clearInterval(interval);
                   resolve(job_num);
                 }
@@ -6642,7 +6652,19 @@ func.datasource.get_value = async function (SESSION_ID, fieldIdP, dsSessionP, ro
         }
       }
     } catch (err) {
-      // console.error(err);
+      await func.utils.report_issue(SESSION_ID, {
+        code: 'RUN_MSG_DSC_060',
+        source: 'Datasource get value',
+        message: 'Datasource row lookup failed',
+        type: 'W',
+        err,
+        details: {
+          dsSessionP,
+          field_id: _field_id,
+          record_id: recordId,
+        },
+        skip_log: false,
+      });
     }
   }
 
@@ -6652,7 +6674,21 @@ func.datasource.get_value = async function (SESSION_ID, fieldIdP, dsSessionP, ro
     if (typeof _ds.data_feed?.rows?.[row_idx]?.[_field_id] !== 'undefined') {
       return await return_value(_field_id, _ds.data_feed.rows[row_idx][_field_id]);
     }
-  } catch (error) {}
+  } catch (error) {
+    await func.utils.report_issue(SESSION_ID, {
+      code: 'RUN_MSG_DSC_060',
+      source: 'Datasource get value',
+      message: 'Datasource row lookup failed',
+      type: 'W',
+      err: error,
+      details: {
+        dsSessionP,
+        field_id: _field_id,
+        record_id: _ds.currentRecordId,
+      },
+      skip_log: false,
+    });
+  }
 
   return await search_in_parameters(fieldIdP);
 };
@@ -7969,11 +8005,213 @@ func.utils.get_drive_url = function (SESSION_ID, val, wrap) {
   }
 };
 
+func.utils._error_registry_module = func.utils._error_registry_module || null;
+func.utils._error_registry_pending = func.utils._error_registry_pending || null;
+
+func.utils.get_error_registry = async function (SESSION_ID) {
+  if (func.utils._error_registry_module) {
+    return func.utils._error_registry_module;
+  }
+
+  if (func.utils._error_registry_pending) {
+    return await func.utils._error_registry_pending;
+  }
+
+  if (!SESSION_ID || !SESSION_OBJ?.[SESSION_ID]) {
+    return null;
+  }
+
+  func.utils._error_registry_pending = func.common
+    .get_module(SESSION_ID, 'xuda-error-registry-module.mjs')
+    .then((module) => {
+      func.utils._error_registry_module = module;
+      return module;
+    })
+    .catch((err) => {
+      console.warn('XUDA WARNING RUN_MSG_NET_010', 'Failed to load error registry module', err);
+      return null;
+    })
+    .finally(() => {
+      func.utils._error_registry_pending = null;
+    });
+
+  return await func.utils._error_registry_pending;
+};
+
+func.utils._normalize_issue_severity = function (type, fallback = 'error') {
+  if (!type) return fallback;
+  const normalized = type.toString().toLowerCase();
+  if (['w', 'warn', 'warning'].includes(normalized)) return 'warning';
+  if (['i', 'info', 'log'].includes(normalized)) return 'info';
+  return 'error';
+};
+
+func.utils._serialize_issue_value = function (value, seen = new WeakSet()) {
+  if (value instanceof Error) {
+    return {
+      name: value.name,
+      message: value.message,
+      stack: value.stack,
+      cause: value.cause,
+    };
+  }
+
+  if (typeof value === 'undefined' || value === null) {
+    return value;
+  }
+
+  if (typeof value === 'function') {
+    return `[Function ${value.name || 'anonymous'}]`;
+  }
+
+  if (typeof value !== 'object') {
+    return value;
+  }
+
+  if (seen.has(value)) {
+    return '[Circular]';
+  }
+
+  seen.add(value);
+
+  if (Array.isArray(value)) {
+    return value.map((item) => func.utils._serialize_issue_value(item, seen));
+  }
+
+  const ret = {};
+  for (const [key, val] of Object.entries(value)) {
+    ret[key] = func.utils._serialize_issue_value(val, seen);
+  }
+  return ret;
+};
+
+func.utils._stringify_issue_message = function (value) {
+  if (typeof value === 'undefined' || value === null) {
+    return '';
+  }
+
+  if (typeof value === 'string') {
+    return value;
+  }
+
+  if (value instanceof Error) {
+    return value.message || value.toString();
+  }
+
+  try {
+    return JSON.stringify(func.utils._serialize_issue_value(value));
+  } catch (error) {
+    return value?.toString?.() || '';
+  }
+};
+
+func.utils._build_fallback_issue_definition = function (payload = {}) {
+  const code = payload.code || 'RUN_MSG_GEN_000';
+  const severity = func.utils._normalize_issue_severity(payload.type || payload.severity, code.startsWith('CHK_MSG_') ? 'warning' : 'error');
+
+  return {
+    code,
+    title: payload.title || (code.startsWith('CHK_MSG_') ? 'Studio Checker Validation Issue' : 'Runtime Error'),
+    severity,
+    domain: code.startsWith('CHK_MSG_') ? 'checker' : 'runtime',
+    category: payload.category || 'general',
+    summary: payload.message || 'The runtime reported an issue.',
+    help_slug: payload.help_slug || code.toLowerCase().replace(/_/g, '-'),
+  };
+};
+
+func.utils.report_issue = async function (SESSION_ID, payload = {}) {
+  const err = payload.err instanceof Error ? payload.err : payload.error instanceof Error ? payload.error : null;
+  const source = payload.source || payload.method || 'runtime';
+  const message = func.utils._stringify_issue_message(
+    typeof payload.message !== 'undefined' ? payload.message : typeof payload.msg !== 'undefined' ? payload.msg : err || payload.details || 'Unknown runtime issue',
+  );
+
+  try {
+    const registry = await func.utils.get_error_registry(SESSION_ID);
+    const registry_payload = {
+      code: payload.code,
+      source,
+      message,
+      type: payload.type || payload.severity,
+      err,
+      details: payload.details,
+      category: payload.category,
+    };
+
+    let definition = null;
+    if (registry?.get_error_definition && payload.code) {
+      definition = registry.get_error_definition(payload.code, registry_payload);
+    }
+    if (!definition && registry?.get_runtime_report_definition) {
+      definition = registry.get_runtime_report_definition(registry_payload);
+    }
+    if (!definition) {
+      definition = func.utils._build_fallback_issue_definition({
+        ...payload,
+        source,
+        message,
+      });
+    }
+
+    const severity = func.utils._normalize_issue_severity(payload.type || payload.severity, definition.severity || 'error');
+    const error_code = definition.code || payload.code || 'RUN_MSG_GEN_000';
+    const error_title = definition.title || payload.title || 'Runtime Error';
+    const help_slug = definition.help_slug || error_code.toLowerCase().replace(/_/g, '-');
+    const console_method = severity === 'warning' ? 'warn' : severity === 'info' ? 'log' : 'error';
+    const _session = SESSION_OBJ?.[SESSION_ID];
+    const report = {
+      error_code,
+      error_title,
+      help_slug,
+      severity,
+      error_domain: definition.domain || 'runtime',
+      error_category: definition.category || payload.category || 'general',
+      source,
+      message,
+      stack: err?.stack || null,
+      app_id: _session?.app_id || payload.app_id || null,
+      session_id: SESSION_ID || null,
+      worker: !!glb?.IS_WORKER,
+      summary: definition.summary || message,
+    };
+    const details = {
+      report,
+      error: func.utils._serialize_issue_value(err),
+      context: func.utils._serialize_issue_value(payload.details),
+      extra: func.utils._serialize_issue_value(payload.extra),
+    };
+    const console_prefix = `XUDA ${console_method.toUpperCase()} ${error_code}`;
+    const console_summary = `${error_title}: ${source}${message ? ' | ' + message : ''}`;
+
+    if (glb?.debug_js && console.groupCollapsed) {
+      console.groupCollapsed(console_prefix, console_summary);
+      console[console_method](report);
+      if (details.context) console.log('context', details.context);
+      if (err) console.error(err);
+      console.groupEnd();
+    } else {
+      console[console_method](console_prefix, console_summary, {
+        help_slug,
+      });
+    }
+
+    if (!payload.skip_log && SESSION_ID && _session) {
+      await func.utils.write_log(SESSION_ID, source, message || error_title, console_method, payload.log_source || 'runtime', details, report);
+    }
+
+    return report;
+  } catch (report_err) {
+    console.error('XUDA ERROR RUN_MSG_GEN_000', 'Failed to report runtime issue', report_err, {
+      source,
+      message,
+      payload,
+    });
+    return null;
+  }
+};
+
 func.utils.debug_report = async function (SESSION_ID, sourceP, msgP, typeP, errP, objP) {
-  var _session = SESSION_OBJ[SESSION_ID];
-  var details = [sourceP];
-  if (errP) details.push(errP);
-  if (objP) details.push(objP);
   if (!typeP || typeP === 'E') {
     setTimeout(() => {
       // if (
@@ -7985,52 +8223,15 @@ func.utils.debug_report = async function (SESSION_ID, sourceP, msgP, typeP, errP
       //   func.index.delete_pouch(SESSION_ID);
       // }
     }, 1000);
-
-    // // temp inactive cause to loop
-
-    // func.utils.alerts.invoke(
-    //   SESSION_ID,
-    //   "system_msg",
-    //   "SYS_MSG_1240",
-    //   "debug",
-    //   null,
-    //   msgP,
-    //   sourceP //arguments.callee.caller.toString()- deprecated es6
-    // );
-    console.error('XUDA', 'ERROR', sourceP, msgP, details);
-
-    if (typeof IS_API_SERVER !== 'undefined' || typeof IS_DOCKER !== 'undefined' || typeof IS_PROCESS_SERVER !== 'undefined') {
-      return __.rpi.write_log(SESSION_OBJ[SESSION_ID].app_id, 'error', 'worker', 'runtime', msgP, null, objP, sourceP);
-    }
-
-    if (glb.IS_WORKER) {
-      let obj = {
-        service: 'write_log',
-        data: msgP,
-        log_type: 'error',
-        id: STUDIO_WEBSOCKET_CONNECTION_ID,
-        uid: _session.USR_OBJ._id,
-        source: 'runtime',
-        app_id: _session.app_id,
-        gtp_token: _session.gtp_token,
-        app_token: _session.app_token,
-      };
-
-      return func.utils.post_back_to_client(SESSION_ID, 'write_log', _session.worker_id, obj);
-    }
-
-    // // temp inactive cause to loop
-    // if (!glb.IS_WORKER) {
-    //   await func.common.db(SESSION_ID, "write_log", {
-    //     client_id: _session?.SYS_GLOBAL_OBJ_CLIENT_INFO?.fingerprint,
-    //     source: sourceP,
-    //     log_type: "error",
-    //     msg: msgP,
-    //   });
-    // }
   }
-  if (typeP === 'W') console.warn('XUDA', 'WARNING', msgP, details);
-  if (typeP === 'I') console.log('XUDA', 'INFO', msgP, details);
+
+  await func.utils.report_issue(SESSION_ID, {
+    source: sourceP,
+    message: msgP,
+    type: typeP,
+    err: errP,
+    details: objP,
+  });
 };
 
 func.utils.request_error = function (SESSION_ID, type, e) {
@@ -8966,8 +9167,18 @@ func.utils.get_plugin_resource = function (SESSION_ID, plugin_name, plugin_resou
       const plugin_resource_res = await import(`${get_path(plugin_resource)}`);
       resolve(plugin_resource_res);
     } catch (err) {
-      console.error(err);
-      reject();
+      await func.utils.report_issue(SESSION_ID, {
+        code: 'RUN_MSG_GUI_020',
+        source: 'func.utils.get_plugin_resource',
+        message: 'plugin setup import failed',
+        err,
+        details: {
+          plugin_name,
+          plugin_resource,
+          plugin_path: get_path(plugin_resource),
+        },
+      });
+      reject(err);
     }
   });
 };
@@ -9017,19 +9228,53 @@ func.utils.get_plugin_npm_cdn = async function (SESSION_ID, plugin_name, resourc
   return get_path(resource);
 };
 
-func.utils.write_log = async function (SESSION_ID, method = '', msg = '', log_type = 'error', source = 'runtime', details) {
+func.utils.write_log = async function (SESSION_ID, method = '', msg = '', log_type = 'error', source = 'runtime', details, meta = {}) {
   const _session = SESSION_OBJ[SESSION_ID];
-  if (typeof IS_API_SERVER !== 'undefined' || typeof IS_DOCKER !== 'undefined' || typeof IS_PROCESS_SERVER !== 'undefined') {
-    return __.rpi.write_log(_session.app_id, log_type, source, msg, details);
-  }
-
-  await func.common.db(SESSION_ID, 'write_log', {
+  const body = {
     msg,
     log_type,
     source,
     details,
     method,
-  });
+    ...meta,
+  };
+
+  if (typeof IS_API_SERVER !== 'undefined' || typeof IS_DOCKER !== 'undefined' || typeof IS_PROCESS_SERVER !== 'undefined') {
+    return __.rpi.write_log(
+      _session?.app_id,
+      log_type,
+      source,
+      msg,
+      details,
+      null,
+      body,
+      method,
+      _session?.SYS_GLOBAL_OBJ_CLIENT_INFO?.fingerprint,
+    );
+  }
+
+  if (glb.IS_WORKER) {
+    let obj = {
+      service: 'write_log',
+      data: body,
+      log_type,
+      id: STUDIO_WEBSOCKET_CONNECTION_ID,
+      uid: _session?.USR_OBJ?._id,
+      source,
+      app_id: _session?.app_id,
+      gtp_token: _session?.gtp_token,
+      app_token: _session?.app_token,
+    };
+
+    return func.utils.post_back_to_client(SESSION_ID, 'write_log', _session.worker_id, obj);
+  }
+
+  await func.common.db(SESSION_ID, 'write_log', body);
+};
+
+func.utils.get_error_catalog_manifest = async function (SESSION_ID) {
+  const registry = await func.utils.get_error_registry(SESSION_ID);
+  return registry?.get_error_catalog_manifest?.() || null;
 };
 
 func.utils.get_resource_filename = function (build, filename) {
@@ -10368,7 +10613,16 @@ func.events.execute_PENDING_OPEN_URL_EVENTS = async function () {
 
       const params_obj = func.common.getObjectFromUrl(url, glb.ROOT_ELEMENT_ATTRIBUTES);
       if (!params_obj.prog) {
-        return console.warn('prog empty');
+        await func.utils.report_issue(SESSION_ID, {
+          code: 'RUN_MSG_EVT_030',
+          source: 'func.events.execute_PENDING_OPEN_URL_EVENTS',
+          message: 'prog empty',
+          type: 'W',
+          details: {
+            url,
+          },
+        });
+        return;
       }
 
       await func.utils.TREE_OBJ.get(SESSION_ID, params_obj.prog);
@@ -10389,18 +10643,37 @@ func.events.execute_PENDING_OPEN_URL_EVENTS = async function () {
           source_functionP: 'pendingUrlEvent_embed',
         });
       } else {
-        console.error('Program not exist', params_obj.prog_id);
+        await func.utils.report_issue(SESSION_ID, {
+          code: 'RUN_MSG_EVT_010',
+          source: 'func.events.execute_PENDING_OPEN_URL_EVENTS',
+          message: 'Program not exist',
+          type: 'E',
+          details: {
+            prog_id: params_obj.prog_id,
+            prog: params_obj.prog,
+          },
+        });
         func.UI.utils.progressScreen.show(SESSION_ID, 'Program not exist', null, true);
       }
     } else {
-      console.warn('url empty');
+      await func.utils.report_issue(SESSION_ID, {
+        code: 'RUN_MSG_EVT_030',
+        source: 'func.events.execute_PENDING_OPEN_URL_EVENTS',
+        message: 'url empty',
+        type: 'W',
+      });
     }
   }
 };
 func.events.invoke = async function (event_id) {
   var _session = SESSION_OBJ[SESSION_ID];
   if (!event_id) {
-    console.warn('event_id Cannot be empty');
+    await func.utils.report_issue(SESSION_ID, {
+      code: 'RUN_MSG_EVT_060',
+      source: 'func.events.invoke',
+      message: 'event_id Cannot be empty',
+      type: 'W',
+    });
     return false;
   }
   var ds;
@@ -10417,7 +10690,15 @@ func.events.invoke = async function (event_id) {
   }
 
   if (!ds) {
-    console.warn('event_id not found');
+    await func.utils.report_issue(SESSION_ID, {
+      code: 'RUN_MSG_EVT_060',
+      source: 'func.events.invoke',
+      message: 'event_id not found',
+      type: 'W',
+      details: {
+        event_id,
+      },
+    });
     return false;
   }
 
@@ -11153,7 +11434,7 @@ func.expression.get_property = async function (valP) {
       });
       return await vm.run(val);
     } catch (err) {
-      throw '';
+      throw err;
     }
   }
 
@@ -11362,11 +11643,23 @@ func.expression.secure_eval = async function (SESSION_ID, sourceP, val, job_id,
     try {
       return eval(val);
     } catch (err) {
+      if (sourceP === 'javascript' && !ignore_errors) {
+        await func.utils.report_issue(SESSION_ID, {
+          code: 'RUN_MSG_EXP_010',
+          source: 'func.expression.secure_eval',
+          message: 'Execution error',
+          type: 'E',
+          err,
+          details: {
+            sourceP,
+            dsSessionP,
+            job_id,
+          },
+        });
+      }
       try {
-        if (sourceP === 'javascript' && !ignore_errors) console.error(err);
         return JSON5.parse(val);
-      } catch (err) {
-        if (sourceP === 'javascript' && !ignore_errors) console.error(err);
+      } catch (json_error) {
         return val;
       }
     }
@@ -11383,13 +11676,22 @@ func.expression.secure_eval = async function (SESSION_ID, sourceP, val, job_id,
     ...(sourceP === 'javascript' ? { axios, got, FormData } : {}),
   };
 
-  const handleError = (err) => {
-    console.error('Execution error:', err);
+  const handleError = async (err) => {
+    await func.utils.report_issue(SESSION_ID, {
+      code: 'RUN_MSG_EXP_010',
+      source: 'func.expression.secure_eval',
+      message: 'Execution error',
+      type: 'E',
+      err,
+      details: {
+        sourceP,
+        dsSessionP,
+        job_id,
+      },
+    });
     func.events.delete_job(SESSION_ID, job_id);
     if (isServer && !SESSION_OBJ[SESSION_ID].crawler) {
-      if (sourceP === 'javascript') {
-        __.rpi.write_log(SESSION_OBJ[SESSION_ID].app_id, 'error', 'worker', 'vm error', err, null, val, 'func.expression.get.secure_eval');
-      } else {
+      if (sourceP !== 'javascript') {
         __.db.add_error_log(SESSION_OBJ[SESSION_ID].app_id, 'api', err);
       }
     }
@@ -11397,10 +11699,12 @@ func.expression.secure_eval = async function (SESSION_ID, sourceP, val, job_id,
   };
 
   if (sourceP === 'javascript') {
-    process.on('uncaughtException', handleError);
+    process.on('uncaughtException', function (uncaught_error) {
+      handleError(uncaught_error);
+    });
     try {
       const dir = path.join(_conf.studio_drive_path, SESSION_OBJ[SESSION_ID].app_id, 'node_modules');
-      const script = new VMScript(`try { ${val} } catch (e) { func.api.error(SESSION_ID, "nodejs error", e); console.error(e); func.events.delete_job(SESSION_ID, "${job_id}"); }`, { filename: dir, dirname: dir });
+      const script = new VMScript(`try { ${val} } catch (e) { func.api.error(SESSION_ID, "nodejs error", e); throw e; }`, { filename: dir, dirname: dir });
       const vm = new NodeVM({
         require: { external: true },
         sandbox,
@@ -11408,7 +11712,7 @@ func.expression.secure_eval = async function (SESSION_ID, sourceP, val, job_id,
       });
       return await vm.run(script, { filename: dir, dirname: dir });
     } catch (err) {
-      return handleError(err);
+      return await handleError(err);
     }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xuda.io/xuda-worker-bundle",
-  "version": "1.3.2698",
+  "version": "1.3.2700",
   "description": "xuda framework",
   "main": "index.js",
   "scripts": {