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

package/dist/node_modules/isolated-vm/src/isolate/inspector.h

@@ -0,0 +1,70 @@
+#pragma once
+#include <v8.h>
+#include "lib/lockable.h"
+#include "runnable.h"
+#include "v8_inspector_wrapper.h"
+#include <condition_variable>
+#include <memory>
+#include <mutex>
+#include <unordered_set>
+
+namespace ivm {
+class IsolateEnvironment;
+class InspectorSession;
+
+/**
+ * This handles communication to the v8 backend. There is only one of these per isolate, but many
+ * sessions may connect to this agent.
+ *
+ * This class combines the role of both V8Inspector and V8InspectorClient into a single class.
+ */
+class InspectorAgent : public v8_inspector::V8InspectorClient {
+	friend class InspectorSession;
+	private:
+		IsolateEnvironment& isolate;
+		std::unique_ptr<v8_inspector::V8Inspector> inspector;
+		std::condition_variable cv;
+		std::mutex mutex;
+		lockable_t<std::unordered_set<InspectorSession*>> active_sessions;
+		bool running = false;
+		bool terminated = false;
+
+		auto ConnectSession(InspectorSession& session) -> std::unique_ptr<v8_inspector::V8InspectorSession>;
+		void SessionDisconnected(InspectorSession& session);
+		void SendInterrupt(std::unique_ptr<Runnable> task);
+
+	public:
+		explicit InspectorAgent(IsolateEnvironment& isolate);
+		~InspectorAgent() override;
+		InspectorAgent(const InspectorAgent&) = delete;
+		auto operator= (const InspectorAgent&) -> InspectorAgent& = delete;
+		void runMessageLoopOnPause(int context_group_id) final;
+		void quitMessageLoopOnPause() final;
+		void ContextCreated(v8::Local<v8::Context> context, const std::string& name);
+		void ContextDestroyed(v8::Local<v8::Context> context);
+		void Terminate();
+};
+
+/**
+ * Individual session to the v8 inspector agent. This probably relays messages from a websocket to
+ * the v8 backend. To use the class you need to implement the abstract methods defined in Channel.
+ *
+ * This class combines the role of both V8Inspector::Channel and V8InspectorSession into a single
+ * class.
+ */
+class InspectorSession : public v8_inspector::V8Inspector::Channel {
+	friend class InspectorAgent;
+	private:
+		InspectorAgent& agent;
+		std::shared_ptr<v8_inspector::V8InspectorSession> session;
+		std::mutex mutex;
+	public:
+		explicit InspectorSession(IsolateEnvironment& isolate);
+		~InspectorSession() override;
+		InspectorSession(const InspectorSession&) = delete;
+		auto operator= (const InspectorSession&) -> InspectorSession& = delete;
+		void Disconnect();
+		void DispatchBackendProtocolMessage(std::vector<uint16_t> message);
+};
+
+} // namespace ivm

package/dist/node_modules/isolated-vm/src/isolate/node_wrapper.h

@@ -0,0 +1,15 @@
+// node.h has some deprecated v8 calls which blow up with warnings
+#pragma once
+#ifdef __clang__
+#pragma clang system_header
+#include <node.h>
+#elif __GNUC__
+#pragma GCC system_header
+#include <node.h>
+#elif _MSC_VER
+#pragma warning(push, 0)
+#include <node.h>
+#pragma warning(pop)
+#else
+#include <node.h>
+#endif

package/dist/node_modules/isolated-vm/src/isolate/platform_delegate.cc

@@ -0,0 +1,22 @@
+#include "platform_delegate.h"
+
+namespace ivm {
+namespace {
+PlatformDelegate delegate;
+}
+
+void PlatformDelegate::InitializeDelegate() {
+	auto context = v8::Isolate::GetCurrent()->GetCurrentContext();
+	auto* node_platform = node::GetMultiIsolatePlatform(node::GetCurrentEnvironment(context));
+	delegate = PlatformDelegate{node_platform};
+}
+
+void PlatformDelegate::RegisterIsolate(v8::Isolate* isolate, node::IsolatePlatformDelegate* isolate_delegate) {
+	delegate.node_platform->RegisterIsolate(isolate, isolate_delegate);
+}
+
+void PlatformDelegate::UnregisterIsolate(v8::Isolate* isolate) {
+	delegate.node_platform->UnregisterIsolate(isolate);
+}
+
+} // namespace ivm

package/dist/node_modules/isolated-vm/src/isolate/platform_delegate.h

@@ -0,0 +1,46 @@
+#pragma once
+#include "lib/lockable.h"
+#include "node_wrapper.h"
+#include "v8_version.h"
+#include <v8-platform.h>
+#include <mutex>
+#include <unordered_map>
+
+namespace ivm {
+
+// Normalize this interface from v8
+class TaskRunner : public v8::TaskRunner {
+	public:
+		// Methods for v8::TaskRunner
+		void PostTask(std::unique_ptr<v8::Task> task) override = 0;
+		void PostDelayedTask(std::unique_ptr<v8::Task> task, double delay_in_seconds) override = 0;
+		void PostIdleTask(std::unique_ptr<v8::IdleTask> /*task*/) final { std::terminate(); }
+		// Can't be final because symbol is also used in IsolatePlatformDelegate
+		auto IdleTasksEnabled() -> bool override { return false; };
+		auto NonNestableTasksEnabled() const -> bool final { return true; }
+		void PostNonNestableDelayedTask(std::unique_ptr<v8::Task> /*task*/, double /*delay_in_seconds*/) final { std::terminate(); }
+		auto NonNestableDelayedTasksEnabled() const -> bool final { return false; }
+};
+
+class PlatformDelegate {
+	public:
+		PlatformDelegate() = default;
+		explicit PlatformDelegate(node::MultiIsolatePlatform* node_platform) : node_platform{node_platform} {}
+		PlatformDelegate(const PlatformDelegate&) = delete;
+		PlatformDelegate(PlatformDelegate&&) = delete;
+		~PlatformDelegate() = default; // NOLINT(modernize-use-override) -- this only sometimes inherits from v8::Platform
+
+		auto operator=(const PlatformDelegate&) = delete;
+		auto operator=(PlatformDelegate&& delegate) noexcept -> PlatformDelegate& {
+			node_platform = std::exchange(delegate.node_platform, nullptr);
+			return *this;
+		}
+
+		static void InitializeDelegate();
+		static void RegisterIsolate(v8::Isolate* isolate, node::IsolatePlatformDelegate* isolate_delegate);
+		static void UnregisterIsolate(v8::Isolate* isolate);
+
+		node::MultiIsolatePlatform* node_platform = nullptr;
+};
+
+} // namespace ivm

package/dist/node_modules/isolated-vm/src/isolate/remote_handle.h

@@ -0,0 +1,164 @@
+#pragma once
+#include "holder.h"
+#include <v8.h>
+#include <memory>
+#include <tuple>
+#include <utility>
+
+namespace ivm {
+void AdjustRemotes(int delta);
+
+namespace detail {
+
+/**
+ * This is basically a tuple that can be constructed in place in a way that v8::Persistent<> will
+ * accept.
+ */
+template <size_t Index, class Type>
+struct HandleTupleElement {
+	HandleTupleElement(v8::Isolate* isolate, v8::Local<Type> local) : persistent{isolate, local} {}
+	v8::Persistent<Type, v8::NonCopyablePersistentTraits<Type>> persistent;
+};
+
+template <class Indices, class ...Types>
+struct HandleTupleImpl;
+
+template <size_t ...Indices, class ...Types_>
+struct HandleTupleImpl<std::index_sequence<Indices...>, Types_...> : HandleTupleElement<Indices, Types_>... {
+	template <class ...Args>
+	explicit HandleTupleImpl(v8::Isolate* isolate, v8::Local<Types_>... locals) :
+		HandleTupleElement<Indices, Types_>{isolate, locals}... {
+	}
+
+	template <size_t Index>
+	auto get() -> auto& {
+		return HandleTupleElement<Index, std::tuple_element_t<Index, std::tuple<Types_...>>>::persistent;
+	}
+
+	static constexpr auto Size = sizeof...(Types_);
+	using Types = std::tuple<Types_...>;
+};
+
+template <class... Types>
+using HandleTuple = HandleTupleImpl<std::make_index_sequence<sizeof...(Types)>, Types...>;
+
+} // namespace detail
+
+/**
+ * This holds a number of persistent handles to some values in a single isolate. It also holds a
+ * handle to the isolate. When the destructor of this class is called it will run `Reset()` on each
+ * handle in the context of the isolate. If the destructor of this class is called after the isolate
+ * has been disposed then Reset() will not be called (but I don't think that causes a memory leak).
+ */
+
+template <class ...Types>
+class RemoteTuple {
+	public:
+		RemoteTuple() = default;
+
+		template <class Disposer>
+		explicit RemoteTuple(v8::Local<Types>... handles, Disposer disposer) :
+			isolate{IsolateHolder::GetCurrent()},
+			handles{
+				new TupleType{v8::Isolate::GetCurrent(), handles...},
+				RemoteHandleFree<Disposer>{IsolateHolder::GetCurrent(), std::move(disposer)}
+			} {
+			AdjustRemotes(sizeof...(Types));
+			static_assert(!v8::NonCopyablePersistentTraits<v8::Value>::kResetInDestructor, "Do not reset in destructor");
+		}
+
+		explicit RemoteTuple(v8::Local<Types>... handles) : RemoteTuple{handles..., DefaultDisposer{}} {}
+
+		operator bool() const { // NOLINT(hicpp-explicit-conversions)
+			return static_cast<bool>(handles);
+		}
+
+		auto GetIsolateHolder() -> IsolateHolder* {
+			return isolate.get();
+		}
+
+		auto GetSharedIsolateHolder() -> std::shared_ptr<IsolateHolder> {
+			return isolate;
+		}
+
+		template <size_t N>
+		auto Deref() const {
+			using Type = std::tuple_element_t<N, std::tuple<Types...>>;
+			return v8::Local<Type>::New(v8::Isolate::GetCurrent(), handles->template get<N>());
+		}
+
+	private:
+		using TupleType = detail::HandleTuple<Types...>;
+
+		struct DefaultDisposer {
+			template <class Type, class ...Rest>
+			void operator()(v8::Persistent<Type>& value, Rest&&... rest) const {
+				value.Reset();
+				(*this)(std::forward<Rest>(rest)...);
+			}
+
+			void operator()() const {}
+		};
+
+		template <class Disposer>
+		class RemoteHandleFree {
+			public:
+				RemoteHandleFree(std::shared_ptr<IsolateHolder> isolate, Disposer disposer) :
+					isolate{std::move(isolate)}, disposer{std::move(disposer)} {}
+
+				void operator()(TupleType* handles) {
+					isolate->ScheduleTask(std::make_unique<DisposalTask<Disposer>>(handles, std::move(disposer)), true, false, true);
+				}
+
+			private:
+				std::shared_ptr<IsolateHolder> isolate;
+				Disposer disposer;
+		};
+
+		template <class Disposer>
+		class DisposalTask : public Runnable {
+			public:
+				explicit DisposalTask(TupleType* handles, Disposer disposer) :
+					handles{handles}, disposer{std::move(disposer)} {}
+
+			private:
+				template <size_t ...Indices>
+				void Apply(std::index_sequence<Indices...> /*unused*/) {
+					disposer(handles->template get<Indices>()...);
+				}
+
+				void Run() final {
+					Apply(std::make_index_sequence<TupleType::Size>{});
+					AdjustRemotes(-static_cast<int>(TupleType::Size));
+				}
+
+				std::unique_ptr<TupleType> handles;
+				Disposer disposer;
+		};
+
+		std::shared_ptr<IsolateHolder> isolate;
+		std::shared_ptr<TupleType> handles;
+};
+
+/**
+ * Convenient when you only need 1 handle
+ */
+template <class Type>
+class RemoteHandle {
+	public:
+		RemoteHandle() = default;
+		explicit RemoteHandle(v8::Local<Type> handle) : handle{handle} {}
+
+		template <class Disposer>
+		RemoteHandle(v8::Local<Type> handle, Disposer disposer) : handle{handle, std::move(disposer)} {}
+
+		operator bool() const { return bool{handle}; } // NOLINT(hicpp-explicit-conversions)
+		auto Deref() const { return handle.template Deref<0>(); }
+		auto GetIsolateHolder() { return handle.GetIsolateHolder(); }
+		auto GetSharedIsolateHolder() { return handle.GetSharedIsolateHolder(); }
+
+	private:
+		RemoteTuple<Type> handle;
+};
+
+} // namespace ivm

package/dist/node_modules/isolated-vm/src/isolate/run_with_timeout.h

@@ -0,0 +1,171 @@
+#pragma once
+#include "environment.h"
+#include "inspector.h"
+#include "runnable.h"
+#include "stack_trace.h"
+#include "lib/suspend.h"
+#include "lib/timer.h"
+#include <chrono>
+#include <memory>
+#include <thread>
+
+namespace ivm {
+
+/**
+ * Grabs a stack trace of the runaway script
+ */
+class TimeoutRunner final : public Runnable {
+	public:
+		struct State {
+			std::condition_variable cv;
+			std::mutex mutex;
+			std::string stack_trace;
+			bool did_finish = false;
+			bool did_release = false;
+			bool did_terminate = false;
+			bool did_timeout = false;
+		};
+
+		explicit TimeoutRunner(State& state) : state{state} {}
+		TimeoutRunner(const TimeoutRunner&) = delete;
+		auto operator=(const TimeoutRunner&) -> TimeoutRunner& = delete;
+
+		~TimeoutRunner() final {
+			std::lock_guard<std::mutex> lock{state.mutex};
+			state.did_release = true;
+			state.cv.notify_all();
+		}
+
+		void Run() final {
+			bool will_terminate = [&]() {
+				std::lock_guard<std::mutex> lock{state.mutex};
+				if (state.did_finish) {
+					return false;
+				} else {
+					state.did_terminate = true;
+					return true;
+				}
+			}();
+			if (will_terminate) {
+				auto& env = IsolateEnvironment::GetCurrent();
+				auto* isolate = env.GetIsolate();
+				state.stack_trace = StackTraceHolder::RenderSingleStack(v8::StackTrace::CurrentStackTrace(isolate, 10));
+				isolate->TerminateExecution();
+				++env.terminate_depth;
+			}
+		}
+
+	private:
+		State& state;
+};
+
+/**
+ * Run some v8 thing with a timeout. Also throws error if memory limit is hit.
+ */
+template <typename F>
+auto RunWithTimeout(uint32_t timeout_ms, F&& fn) -> v8::Local<v8::Value> {
+	IsolateEnvironment& isolate = IsolateEnvironment::GetCurrent();
+	thread_suspend_handle thread_suspend{};
+	bool is_default_thread = Executor::IsDefaultThread();
+	bool did_terminate = false;
+	TimeoutRunner::State state;
+	v8::MaybeLocal<v8::Value> result;
+	{
+		std::unique_ptr<timer_t> timer_ptr;
+		if (timeout_ms != 0) {
+			timer_ptr = std::make_unique<timer_t>(timeout_ms, &isolate.timer_holder, [&](void* next) {
+				auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds{5};
+
+				{
+					std::lock_guard<std::mutex> lock{state.mutex};
+					if (state.did_finish) {
+						// Timer triggered as the function was finishing, bail early
+						timer_t::chain(next);
+						return;
+					}
+					// Set up interrupt
+					state.did_timeout = true;
+					auto timeout_runner = std::make_unique<TimeoutRunner>(state);
+					if (is_default_thread) {
+						// In this case this is a pure sync function. We should not cancel any async waits.
+						auto lock = isolate.scheduler->Lock();
+						lock->sync_interrupts.push(std::move(timeout_runner));
+						lock->InterruptSyncIsolate();
+					} else {
+						{
+							auto lock = isolate.scheduler->Lock();
+							lock->CancelAsync();
+							lock->interrupts.push(std::move(timeout_runner));
+							lock->InterruptIsolate();
+						}
+					}
+				}
+				timer_t::chain(next);
+
+				// Wait for TimeoutRunner release (either it ran, or was cancelled)
+				{
+					std::unique_lock<std::mutex> lock{state.mutex};
+					if (isolate.error_handler) {
+						if (!state.cv.wait_until(lock, deadline, [&] { return state.did_release || state.did_finish; })) {
+							assert(RaiseCatastrophicError(isolate.error_handler, "Script failed to terminate"));
+							thread_suspend.suspend();
+							return;
+						}
+					} else {
+						state.cv.wait(lock, [&] { return state.did_release || state.did_finish; });
+					}
+					if (state.did_finish) {
+						return;
+					}
+				}
+
+				// Wait for `fn()` to return
+				while (true) {
+					std::lock_guard<std::mutex> lock{state.mutex};
+					if (state.did_finish) {
+						return;
+					} else if (isolate.error_handler && deadline < std::chrono::steady_clock::now()) {
+						assert(RaiseCatastrophicError(isolate.error_handler, "Script failed to terminate"));
+						thread_suspend.suspend();
+						return;
+					}
+					// Aggressively terminate the isolate because sometimes v8 just doesn't get the hint
+					isolate->TerminateExecution();
+				}
+			});
+		}
+
+		if (!isolate.terminated) {
+			result = fn();
+		}
+		bool will_flush_tasks = false;
+		{
+			std::lock_guard<std::mutex> lock{state.mutex};
+			did_terminate = state.did_terminate;
+			will_flush_tasks = state.did_timeout && !state.did_release;
+			state.did_finish = true;
+		}
+		if (will_flush_tasks) {
+			// TimeoutRunner was added to interupts after v8 yielded control. In this case we flush
+			// interrupt tasks manually
+			if (is_default_thread) {
+				isolate.InterruptEntrySync();
+			} else {
+				isolate.InterruptEntryAsync();
+			}
+		}
+	}
+	if (isolate.DidHitMemoryLimit()) {
+		throw FatalRuntimeError("Isolate was disposed during execution due to memory limit");
+	} else if (isolate.terminated) {
+		throw FatalRuntimeError("Isolate was disposed during execution");
+	} else if (did_terminate) {
+		if (--isolate.terminate_depth == 0) {
+			isolate->CancelTerminateExecution();
+		}
+		throw RuntimeGenericError("Script execution timed out.", std::move(state.stack_trace));
+	}
+	return Unmaybe(result);
+}
+
+} // namespace ivm

package/dist/node_modules/isolated-vm/src/isolate/runnable.h

@@ -0,0 +1,29 @@
+#pragma once
+#include <v8-platform.h>
+
+namespace ivm {
+// ivm::Runnable serves the same role as v8::Task but instances of Runnable live and die without v8
+// so it might not actually make sense to use a v8 container for the job. An alias is used to avoid
+// the adapter which would be needed in the case where a Runnable actually does need to be passed
+// off to v8.
+using Runnable = v8::Task;
+/*
+class Runnable {
+	public:
+		virtual ~Runnable() = default;
+		virtual void Run() = 0;
+};
+
+class TaskHolder : public Runnable {
+	private:
+		std::unique_ptr<v8::Task> task;
+	public:
+		explicit TaskHolder(v8::Task* task) : task{task} {}
+		explicit TaskHolder(std::unique_ptr<v8::Task> task) : task{std::move(task)} {}
+		TaskHolder(TaskHolder task) noexcept : task{std::move(task.task)} {}
+		void Run() final {
+			task->Run();
+		}
+};
+*/
+} // namespace ivm