@nocobase/plugin-workflow-javascript 2.1.0-beta.10 → 2.1.0-beta.12

package/dist/node_modules/isolated-vm/vendor/v8_inspector/nodejs_v22.0.0.h

@@ -0,0 +1,419 @@
+// Copyright 2016 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef V8_V8_INSPECTOR_H_
+#define V8_V8_INSPECTOR_H_
+
+#include <stdint.h>
+
+#include <cctype>
+#include <memory>
+
+#include "v8-isolate.h"       // NOLINT(build/include_directory)
+#include "v8-local-handle.h"  // NOLINT(build/include_directory)
+
+namespace v8 {
+class Context;
+class Name;
+class Object;
+class StackTrace;
+class Value;
+}  // namespace v8
+
+namespace v8_inspector {
+
+namespace internal {
+class V8DebuggerId;
+}  // namespace internal
+
+namespace protocol {
+namespace Debugger {
+namespace API {
+class SearchMatch;
+}
+}  // namespace Debugger
+namespace Runtime {
+namespace API {
+class RemoteObject;
+class StackTrace;
+class StackTraceId;
+}  // namespace API
+}  // namespace Runtime
+namespace Schema {
+namespace API {
+class Domain;
+}
+}  // namespace Schema
+}  // namespace protocol
+
+class V8_EXPORT StringView {
+ public:
+  StringView() : m_is8Bit(true), m_length(0), m_characters8(nullptr) {}
+
+  StringView(const uint8_t* characters, size_t length)
+      : m_is8Bit(true), m_length(length), m_characters8(characters) {}
+
+  StringView(const uint16_t* characters, size_t length)
+      : m_is8Bit(false), m_length(length), m_characters16(characters) {}
+
+  bool is8Bit() const { return m_is8Bit; }
+  size_t length() const { return m_length; }
+
+  // TODO(dgozman): add DCHECK(m_is8Bit) to accessors once platform can be used
+  // here.
+  const uint8_t* characters8() const { return m_characters8; }
+  const uint16_t* characters16() const { return m_characters16; }
+
+ private:
+  bool m_is8Bit;
+  size_t m_length;
+  union {
+    const uint8_t* m_characters8;
+    const uint16_t* m_characters16;
+  };
+};
+
+class V8_EXPORT StringBuffer {
+ public:
+  virtual ~StringBuffer() = default;
+  virtual StringView string() const = 0;
+  // This method copies contents.
+  static std::unique_ptr<StringBuffer> create(StringView);
+};
+
+class V8_EXPORT V8ContextInfo {
+ public:
+  V8ContextInfo(v8::Local<v8::Context> context, int contextGroupId,
+                StringView humanReadableName)
+      : context(context),
+        contextGroupId(contextGroupId),
+        humanReadableName(humanReadableName),
+        hasMemoryOnConsole(false) {}
+
+  v8::Local<v8::Context> context;
+  // Each v8::Context is a part of a group. The group id must be non-zero.
+  int contextGroupId;
+  StringView humanReadableName;
+  StringView origin;
+  StringView auxData;
+  bool hasMemoryOnConsole;
+
+  static int executionContextId(v8::Local<v8::Context> context);
+
+  // Disallow copying and allocating this one.
+  enum NotNullTagEnum { NotNullLiteral };
+  void* operator new(size_t) = delete;
+  void* operator new(size_t, NotNullTagEnum, void*) = delete;
+  void* operator new(size_t, void*) = delete;
+  V8ContextInfo(const V8ContextInfo&) = delete;
+  V8ContextInfo& operator=(const V8ContextInfo&) = delete;
+};
+
+// This debugger id tries to be unique by generating two random
+// numbers, which should most likely avoid collisions.
+// Debugger id has a 1:1 mapping to context group. It is used to
+// attribute stack traces to a particular debugging, when doing any
+// cross-debugger operations (e.g. async step in).
+// See also Runtime.UniqueDebuggerId in the protocol.
+class V8_EXPORT V8DebuggerId {
+ public:
+  V8DebuggerId() = default;
+  V8DebuggerId(const V8DebuggerId&) = default;
+  V8DebuggerId& operator=(const V8DebuggerId&) = default;
+
+  std::unique_ptr<StringBuffer> toString() const;
+  bool isValid() const;
+  std::pair<int64_t, int64_t> pair() const;
+
+ private:
+  friend class internal::V8DebuggerId;
+  explicit V8DebuggerId(std::pair<int64_t, int64_t>);
+
+  int64_t m_first = 0;
+  int64_t m_second = 0;
+};
+
+struct V8_EXPORT V8StackFrame {
+  StringView sourceURL;
+  StringView functionName;
+  int lineNumber;
+  int columnNumber;
+};
+
+class V8_EXPORT V8StackTrace {
+ public:
+  virtual StringView firstNonEmptySourceURL() const = 0;
+  virtual bool isEmpty() const = 0;
+  virtual StringView topSourceURL() const = 0;
+  virtual int topLineNumber() const = 0;
+  virtual int topColumnNumber() const = 0;
+  virtual int topScriptId() const = 0;
+  virtual StringView topFunctionName() const = 0;
+
+  virtual ~V8StackTrace() = default;
+  virtual std::unique_ptr<protocol::Runtime::API::StackTrace>
+  buildInspectorObject(int maxAsyncDepth) const = 0;
+  virtual std::unique_ptr<StringBuffer> toString() const = 0;
+
+  // Safe to pass between threads, drops async chain.
+  virtual std::unique_ptr<V8StackTrace> clone() = 0;
+
+  virtual std::vector<V8StackFrame> frames() const = 0;
+};
+
+class V8_EXPORT V8InspectorSession {
+ public:
+  virtual ~V8InspectorSession() = default;
+
+  // Cross-context inspectable values (DOM nodes in different worlds, etc.).
+  class V8_EXPORT Inspectable {
+   public:
+    virtual v8::Local<v8::Value> get(v8::Local<v8::Context>) = 0;
+    virtual ~Inspectable() = default;
+  };
+  virtual void addInspectedObject(std::unique_ptr<Inspectable>) = 0;
+
+  // Dispatching protocol messages.
+  static bool canDispatchMethod(StringView method);
+  virtual void dispatchProtocolMessage(StringView message) = 0;
+  virtual std::vector<uint8_t> state() = 0;
+  virtual std::vector<std::unique_ptr<protocol::Schema::API::Domain>>
+  supportedDomains() = 0;
+
+  // Debugger actions.
+  virtual void schedulePauseOnNextStatement(StringView breakReason,
+                                            StringView breakDetails) = 0;
+  virtual void cancelPauseOnNextStatement() = 0;
+  virtual void breakProgram(StringView breakReason,
+                            StringView breakDetails) = 0;
+  virtual void setSkipAllPauses(bool) = 0;
+  virtual void resume(bool setTerminateOnResume = false) = 0;
+  virtual void stepOver() = 0;
+  virtual std::vector<std::unique_ptr<protocol::Debugger::API::SearchMatch>>
+  searchInTextByLines(StringView text, StringView query, bool caseSensitive,
+                      bool isRegex) = 0;
+
+  // Remote objects.
+  virtual std::unique_ptr<protocol::Runtime::API::RemoteObject> wrapObject(
+      v8::Local<v8::Context>, v8::Local<v8::Value>, StringView groupName,
+      bool generatePreview) = 0;
+
+  virtual bool unwrapObject(std::unique_ptr<StringBuffer>* error,
+                            StringView objectId, v8::Local<v8::Value>*,
+                            v8::Local<v8::Context>*,
+                            std::unique_ptr<StringBuffer>* objectGroup) = 0;
+  virtual void releaseObjectGroup(StringView) = 0;
+  virtual void triggerPreciseCoverageDeltaUpdate(StringView occasion) = 0;
+
+  struct V8_EXPORT EvaluateResult {
+    enum class ResultType {
+      kNotRun,
+      kSuccess,
+      kException,
+    };
+
+    ResultType type;
+    v8::Local<v8::Value> value;
+  };
+  // Evalaute 'expression' in the provided context. Does the same as
+  // Runtime#evaluate under-the-hood but exposed on the C++ side.
+  virtual EvaluateResult evaluate(v8::Local<v8::Context> context,
+                                  StringView expression,
+                                  bool includeCommandLineAPI = false) = 0;
+
+  // Prepare for shutdown (disables debugger pausing, etc.).
+  virtual void stop() = 0;
+};
+
+struct V8_EXPORT DeepSerializedValue {
+  explicit DeepSerializedValue(std::unique_ptr<StringBuffer> type,
+                               v8::MaybeLocal<v8::Value> value = {})
+      : type(std::move(type)), value(value) {}
+  std::unique_ptr<StringBuffer> type;
+  v8::MaybeLocal<v8::Value> value;
+};
+
+struct V8_EXPORT DeepSerializationResult {
+  explicit DeepSerializationResult(
+      std::unique_ptr<DeepSerializedValue> serializedValue)
+      : serializedValue(std::move(serializedValue)), isSuccess(true) {}
+  explicit DeepSerializationResult(std::unique_ptr<StringBuffer> errorMessage)
+      : errorMessage(std::move(errorMessage)), isSuccess(false) {}
+
+  // Use std::variant when available.
+  std::unique_ptr<DeepSerializedValue> serializedValue;
+  std::unique_ptr<StringBuffer> errorMessage;
+  bool isSuccess;
+};
+
+class V8_EXPORT V8InspectorClient {
+ public:
+  virtual ~V8InspectorClient() = default;
+
+  virtual void runMessageLoopOnPause(int contextGroupId) {}
+  virtual void runMessageLoopOnInstrumentationPause(int contextGroupId) {
+    runMessageLoopOnPause(contextGroupId);
+  }
+  virtual void quitMessageLoopOnPause() {}
+  virtual void runIfWaitingForDebugger(int contextGroupId) {}
+
+  virtual void muteMetrics(int contextGroupId) {}
+  virtual void unmuteMetrics(int contextGroupId) {}
+
+  virtual void beginUserGesture() {}
+  virtual void endUserGesture() {}
+
+  virtual std::unique_ptr<DeepSerializationResult> deepSerialize(
+      v8::Local<v8::Value> v8Value, int maxDepth,
+      v8::Local<v8::Object> additionalParameters) {
+    return nullptr;
+  }
+  virtual std::unique_ptr<StringBuffer> valueSubtype(v8::Local<v8::Value>) {
+    return nullptr;
+  }
+  virtual std::unique_ptr<StringBuffer> descriptionForValueSubtype(
+      v8::Local<v8::Context>, v8::Local<v8::Value>) {
+    return nullptr;
+  }
+  virtual bool isInspectableHeapObject(v8::Local<v8::Object>) { return true; }
+
+  virtual v8::Local<v8::Context> ensureDefaultContextInGroup(
+      int contextGroupId) {
+    return v8::Local<v8::Context>();
+  }
+  virtual void beginEnsureAllContextsInGroup(int contextGroupId) {}
+  virtual void endEnsureAllContextsInGroup(int contextGroupId) {}
+
+  virtual void installAdditionalCommandLineAPI(v8::Local<v8::Context>,
+                                               v8::Local<v8::Object>) {}
+  virtual void consoleAPIMessage(int contextGroupId,
+                                 v8::Isolate::MessageErrorLevel level,
+                                 const StringView& message,
+                                 const StringView& url, unsigned lineNumber,
+                                 unsigned columnNumber, V8StackTrace*) {}
+  virtual v8::MaybeLocal<v8::Value> memoryInfo(v8::Isolate*,
+                                               v8::Local<v8::Context>) {
+    return v8::MaybeLocal<v8::Value>();
+  }
+
+  virtual void consoleTime(const StringView& title) {}
+  virtual void consoleTimeEnd(const StringView& title) {}
+  virtual void consoleTimeStamp(const StringView& title) {}
+  virtual void consoleClear(int contextGroupId) {}
+  virtual double currentTimeMS() { return 0; }
+  typedef void (*TimerCallback)(void*);
+  virtual void startRepeatingTimer(double, TimerCallback, void* data) {}
+  virtual void cancelTimer(void* data) {}
+
+  // TODO(dgozman): this was added to support service worker shadow page. We
+  // should not connect at all.
+  virtual bool canExecuteScripts(int contextGroupId) { return true; }
+
+  virtual void maxAsyncCallStackDepthChanged(int depth) {}
+
+  virtual std::unique_ptr<StringBuffer> resourceNameToUrl(
+      const StringView& resourceName) {
+    return nullptr;
+  }
+
+  // The caller would defer to generating a random 64 bit integer if
+  // this method returns 0.
+  virtual int64_t generateUniqueId() { return 0; }
+
+  virtual void dispatchError(v8::Local<v8::Context>, v8::Local<v8::Message>,
+                             v8::Local<v8::Value>) {}
+};
+
+// These stack trace ids are intended to be passed between debuggers and be
+// resolved later. This allows to track cross-debugger calls and step between
+// them if a single client connects to multiple debuggers.
+struct V8_EXPORT V8StackTraceId {
+  uintptr_t id;
+  std::pair<int64_t, int64_t> debugger_id;
+  bool should_pause = false;
+
+  V8StackTraceId();
+  V8StackTraceId(const V8StackTraceId&) = default;
+  V8StackTraceId(uintptr_t id, const std::pair<int64_t, int64_t> debugger_id);
+  V8StackTraceId(uintptr_t id, const std::pair<int64_t, int64_t> debugger_id,
+                 bool should_pause);
+  explicit V8StackTraceId(StringView);
+  V8StackTraceId& operator=(const V8StackTraceId&) = default;
+  V8StackTraceId& operator=(V8StackTraceId&&) noexcept = default;
+  ~V8StackTraceId() = default;
+
+  bool IsInvalid() const;
+  std::unique_ptr<StringBuffer> ToString();
+};
+
+class V8_EXPORT V8Inspector {
+ public:
+  static std::unique_ptr<V8Inspector> create(v8::Isolate*, V8InspectorClient*);
+  virtual ~V8Inspector() = default;
+
+  // Contexts instrumentation.
+  virtual void contextCreated(const V8ContextInfo&) = 0;
+  virtual void contextDestroyed(v8::Local<v8::Context>) = 0;
+  virtual void resetContextGroup(int contextGroupId) = 0;
+  virtual v8::MaybeLocal<v8::Context> contextById(int contextId) = 0;
+  virtual V8DebuggerId uniqueDebuggerId(int contextId) = 0;
+
+  // Various instrumentation.
+  virtual void idleStarted() = 0;
+  virtual void idleFinished() = 0;
+
+  // Async stack traces instrumentation.
+  virtual void asyncTaskScheduled(StringView taskName, void* task,
+                                  bool recurring) = 0;
+  virtual void asyncTaskCanceled(void* task) = 0;
+  virtual void asyncTaskStarted(void* task) = 0;
+  virtual void asyncTaskFinished(void* task) = 0;
+  virtual void allAsyncTasksCanceled() = 0;
+
+  virtual V8StackTraceId storeCurrentStackTrace(StringView description) = 0;
+  virtual void externalAsyncTaskStarted(const V8StackTraceId& parent) = 0;
+  virtual void externalAsyncTaskFinished(const V8StackTraceId& parent) = 0;
+
+  // Exceptions instrumentation.
+  virtual unsigned exceptionThrown(v8::Local<v8::Context>, StringView message,
+                                   v8::Local<v8::Value> exception,
+                                   StringView detailedMessage, StringView url,
+                                   unsigned lineNumber, unsigned columnNumber,
+                                   std::unique_ptr<V8StackTrace>,
+                                   int scriptId) = 0;
+  virtual void exceptionRevoked(v8::Local<v8::Context>, unsigned exceptionId,
+                                StringView message) = 0;
+  virtual bool associateExceptionData(v8::Local<v8::Context>,
+                                      v8::Local<v8::Value> exception,
+                                      v8::Local<v8::Name> key,
+                                      v8::Local<v8::Value> value) = 0;
+
+  // Connection.
+  class V8_EXPORT Channel {
+   public:
+    virtual ~Channel() = default;
+    virtual void sendResponse(int callId,
+                              std::unique_ptr<StringBuffer> message) = 0;
+    virtual void sendNotification(std::unique_ptr<StringBuffer> message) = 0;
+    virtual void flushProtocolNotifications() = 0;
+  };
+  enum ClientTrustLevel { kUntrusted, kFullyTrusted };
+  enum SessionPauseState { kWaitingForDebugger, kNotWaitingForDebugger };
+  // TODO(chromium:1352175): remove default value once downstream change lands.
+  virtual std::unique_ptr<V8InspectorSession> connect(
+      int contextGroupId, Channel*, StringView state,
+      ClientTrustLevel client_trust_level,
+      SessionPauseState = kNotWaitingForDebugger) {
+    return nullptr;
+  }
+
+  // API methods.
+  virtual std::unique_ptr<V8StackTrace> createStackTrace(
+      v8::Local<v8::StackTrace>) = 0;
+  virtual std::unique_ptr<V8StackTrace> captureStackTrace(bool fullStack) = 0;
+};
+
+}  // namespace v8_inspector
+
+#endif  // V8_V8_INSPECTOR_H_

package/dist/node_modules/winston-transport/package.json

@@ -1 +1 @@
-{"name":"winston-transport","description":"Base stream implementations for winston@3 and up.","version":"4.7.0","main":"index.js","browser":"dist/index.js","scripts":{"lint":"eslint test/*.js index.js --resolve-plugins-relative-to ./node_modules/@dabh/eslint-config-populist","pretest":"npm run lint && npm run build","test":"nyc mocha test/*.test.js","report":"nyc report --reporter=lcov","build":"rimraf dist && babel *.js -d ./dist","prepublishOnly":"npm run build"},"repository":{"type":"git","url":"git@github.com:winstonjs/winston-transport.git"},"keywords":["winston","transport","winston3"],"author":"Charlie Robbins <charlie.robbins@gmail.com>","license":"MIT","bugs":{"url":"https://github.com/winstonjs/winston-transport/issues"},"homepage":"https://github.com/winstonjs/winston-transport#readme","dependencies":{"logform":"^2.3.2","readable-stream":"^3.6.0","triple-beam":"^1.3.0"},"devDependencies":{"@types/node":"^20.8.6","abstract-winston-transport":">=0.5.1","assume":"^2.3.0","babel-cli":"^6.26.0","babel-preset-env":"^1.7.0","deep-equal":"^2.0.5","eslint":"^8.8.0","@dabh/eslint-config-populist":"^5.0.0","mocha":"^10.0.0","nyc":"^15.1.0","rimraf":"^5.0.5","winston-compat":"^0.1.5"},"engines":{"node":">= 12.0.0"},"_lastModified":"2026-03-19T03:17:04.548Z"}
+{"name":"winston-transport","description":"Base stream implementations for winston@3 and up.","version":"4.7.0","main":"index.js","browser":"dist/index.js","scripts":{"lint":"eslint test/*.js index.js --resolve-plugins-relative-to ./node_modules/@dabh/eslint-config-populist","pretest":"npm run lint && npm run build","test":"nyc mocha test/*.test.js","report":"nyc report --reporter=lcov","build":"rimraf dist && babel *.js -d ./dist","prepublishOnly":"npm run build"},"repository":{"type":"git","url":"git@github.com:winstonjs/winston-transport.git"},"keywords":["winston","transport","winston3"],"author":"Charlie Robbins <charlie.robbins@gmail.com>","license":"MIT","bugs":{"url":"https://github.com/winstonjs/winston-transport/issues"},"homepage":"https://github.com/winstonjs/winston-transport#readme","dependencies":{"logform":"^2.3.2","readable-stream":"^3.6.0","triple-beam":"^1.3.0"},"devDependencies":{"@types/node":"^20.8.6","abstract-winston-transport":">=0.5.1","assume":"^2.3.0","babel-cli":"^6.26.0","babel-preset-env":"^1.7.0","deep-equal":"^2.0.5","eslint":"^8.8.0","@dabh/eslint-config-populist":"^5.0.0","mocha":"^10.0.0","nyc":"^15.1.0","rimraf":"^5.0.5","winston-compat":"^0.1.5"},"engines":{"node":">= 12.0.0"},"_lastModified":"2026-04-08T08:19:15.597Z"}

package/dist/server/IsolatedVm.js

@@ -0,0 +1,75 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+const { parentPort, workerData } = require("node:worker_threads");
+const ivm = require("isolated-vm");
+async function main() {
+  const { source, args = {}, options = {} } = workerData;
+  const isolate = new ivm.Isolate({ memoryLimit: 128 });
+  try {
+    const context = await isolate.createContext();
+    const jail = context.global;
+    const logCb = new ivm.Callback((...a) => console.log(...a));
+    const warnCb = new ivm.Callback((...a) => console.warn(...a));
+    const errorCb = new ivm.Callback((...a) => console.error(...a));
+    await jail.set("__logCb", logCb);
+    await jail.set("__warnCb", warnCb);
+    await jail.set("__errorCb", errorCb);
+    await context.eval(`
+      const console = Object.freeze({
+        log:            __logCb,
+        info:           __logCb,
+        warn:           __warnCb,
+        error:          __errorCb,
+        debug:          __logCb,
+        trace:          __logCb,
+        dir:            __logCb,
+        dirxml:         __logCb,
+        table:          __logCb,
+        time:           function() {},
+        timeEnd:        function() {},
+        timeLog:        function() {},
+        count:          function() {},
+        countReset:     function() {},
+        group:          function() {},
+        groupCollapsed: function() {},
+        groupEnd:       function() {},
+        clear:          function() {},
+        assert:         function(cond, ...a) { if (!cond) __errorCb('Assertion failed:', ...a); },
+      });
+      delete globalThis.__logCb;
+      delete globalThis.__warnCb;
+      delete globalThis.__errorCb;
+    `);
+    for (const [key, value] of Object.entries(args)) {
+      const val = value === void 0 ? null : value;
+      await jail.set(key, new ivm.ExternalCopy(val).copyInto());
+    }
+    const code = `
+      (async function __main() {
+        ${source}
+      })()
+    `;
+    const result = await context.eval(code, {
+      timeout: options.timeout || void 0,
+      promise: true,
+      copy: true
+    });
+    return result;
+  } finally {
+    if (!isolate.isDisposed) {
+      isolate.dispose();
+    }
+  }
+}
+main().then((result) => {
+  parentPort.postMessage({ type: "result", result });
+}).catch((error) => {
+  throw error;
+});

package/dist/server/ScriptInstruction.d.ts

@@ -17,6 +17,12 @@ type ScriptConfig = {
     }[];
 };
 export default class ScriptInstruction extends Instruction {
+    /**
+     * Returns the worker script path based on whether WORKFLOW_SCRIPT_MODULES is configured.
+     * - WORKFLOW_SCRIPT_MODULES set: uses Node.js vm with require support (module whitelist)
+     * - WORKFLOW_SCRIPT_MODULES unset: uses isolated-vm for maximum security (no require, no Node.js APIs)
+     */
+    static get workerScript(): string;
     static run(source: any, args: any, options: {
         logger: Logger;
         timeout?: number;

package/dist/server/ScriptInstruction.js

@@ -46,10 +46,20 @@ var import_winston = __toESM(require("winston"));
 var import_plugin_workflow = require("@nocobase/plugin-workflow");
 var import_cache_logger = require("./cache-logger");
 class ScriptInstruction extends import_plugin_workflow.Instruction {
+  /**
+   * Returns the worker script path based on whether WORKFLOW_SCRIPT_MODULES is configured.
+   * - WORKFLOW_SCRIPT_MODULES set: uses Node.js vm with require support (module whitelist)
+   * - WORKFLOW_SCRIPT_MODULES unset: uses isolated-vm for maximum security (no require, no Node.js APIs)
+   */
+  static get workerScript() {
+    var _a;
+    const hasModules = ((_a = process.env.WORKFLOW_SCRIPT_MODULES) == null ? void 0 : _a.split(",").filter(Boolean).length) > 0;
+    return import_node_path.default.join(__dirname, hasModules ? "Vm.js" : "IsolatedVm.js");
+  }
   static async run(source, args, options) {
     const { logger, timeout } = options;
     let result;
-    const worker = new import_node_worker_threads.Worker(import_node_path.default.join(__dirname, "Vm.js"), {
+    const worker = new import_node_worker_threads.Worker(this.workerScript, {
       workerData: { source, args, options: timeout ? { timeout } : {} }
     });
     worker.on("message", (message) => {

package/dist/server/Vm.js

@@ -28,43 +28,58 @@ function customRequire(m) {
   }
   throw new Error(`module "${m}" not supported`);
 }
-customRequire.constructor = null;
-function createSafeConsole(originalConsole) {
-  const safe = /* @__PURE__ */ Object.create(null);
-  Object.defineProperty(safe, "constructor", {
+function hardenFunction(fn) {
+  Object.setPrototypeOf(fn, null);
+  Object.defineProperty(fn, "constructor", {
     value: null,
     writable: false,
     enumerable: false,
     configurable: false
   });
-  const allKeys = Reflect.ownKeys(originalConsole);
-  for (const key of allKeys) {
-    const descriptor = Object.getOwnPropertyDescriptor(originalConsole, key);
-    if (!descriptor) {
-      continue;
-    }
-    const wrap = (fn) => {
-      const bound = fn.bind(originalConsole);
-      Object.defineProperty(bound, "constructor", {
-        value: null,
+  return fn;
+}
+hardenFunction(customRequire);
+function createSafeConsole(originalConsole) {
+  const safe = /* @__PURE__ */ Object.create(null);
+  const allowedMethods = [
+    "log",
+    "info",
+    "warn",
+    "error",
+    "debug",
+    "trace",
+    "dir",
+    "dirxml",
+    "table",
+    "time",
+    "timeEnd",
+    "timeLog",
+    "count",
+    "countReset",
+    "group",
+    "groupCollapsed",
+    "groupEnd",
+    "clear",
+    "assert"
+  ];
+  for (const key of allowedMethods) {
+    if (typeof originalConsole[key] === "function") {
+      const bound = originalConsole[key].bind(originalConsole);
+      hardenFunction(bound);
+      Object.defineProperty(safe, key, {
+        value: bound,
         writable: false,
-        enumerable: false,
+        enumerable: true,
         configurable: false
       });
-      return bound;
-    };
-    if (typeof descriptor.value === "function") {
-      descriptor.value = wrap(descriptor.value);
-    }
-    if (typeof descriptor.get === "function") {
-      descriptor.get = wrap(descriptor.get);
     }
-    if (typeof descriptor.set === "function") {
-      descriptor.set = wrap(descriptor.set);
-    }
-    descriptor.configurable = false;
-    Object.defineProperty(safe, key, descriptor);
   }
+  Object.defineProperty(safe, "constructor", {
+    value: null,
+    writable: false,
+    enumerable: false,
+    configurable: false
+  });
   return Object.freeze(safe);
 }
 async function main() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/plugin-workflow-javascript",
-  "version": "2.1.0-beta.10",
+  "version": "2.1.0-beta.12",
   "displayName": "Workflow: JavaScript",
   "displayName.zh-CN": "工作流：JavaScript 节点",
   "description": "Execute a piece of JavaScript in an isolated Node.js environment.",
@@ -25,6 +25,7 @@
     "@codemirror/state": "^6.4.1",
     "@codemirror/view": "^6.37.2",
     "codemirror": "^6.0.2",
+    "isolated-vm": "^5.0.4",
     "jshint": "^2.13.6",
     "node-gyp": "^10.2.0"
   },
@@ -36,5 +37,5 @@
     "Workflow"
   ],
   "license": "Apache-2.0",
-  "gitHead": "f7e467710d4748f7089b779494b220025b39bc02"
+  "gitHead": "25cee9643f42f850afc4adc33c55a56850ac730d"
 }