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

package/dist/node_modules/isolated-vm/src/isolate/generic/handle_cast.h

@@ -0,0 +1,257 @@
+#pragma once
+#include <v8.h>
+#include "error.h"
+#include "../v8_version.h"
+
+namespace ivm {
+
+// Internal handle conversion error. All these `HandleCastImpl` functions are templated and inlined and
+// throwing generates verbose asm so this is implementated as a static function to clean up the
+// typical case
+struct ParamIncorrect : std::exception {
+	explicit ParamIncorrect(const char* type) : type{type} {}
+	[[noreturn]] static void Throw(const char* type) { throw ParamIncorrect{type}; }
+	const char* type;
+};
+
+// Common arguments for casting functions
+class HandleCastArguments {
+	private:
+		// Most of the time we won't need the context (and it is never needed in "strict" casting mode).
+		// This little holder will only call GetCurrentContext() when needed because the optimizer can't
+		// elide the call in any circumstances
+		class ContextHolder {
+			public:
+				explicit ContextHolder(v8::Isolate* isolate) : isolate{isolate} {}
+				inline operator v8::Local<v8::Context>() const { // NOLINT(hicpp-explicit-conversions)
+					if (context.IsEmpty()) {
+						context = isolate->GetCurrentContext();
+					}
+					return context;
+				}
+
+			private:
+				v8::Isolate* const isolate;
+				mutable v8::Local<v8::Context> context{};
+		};
+
+	public:
+		HandleCastArguments() : HandleCastArguments{true, v8::Isolate::GetCurrent()} {}
+
+		HandleCastArguments(bool strict, v8::Isolate* isolate) :
+			isolate{isolate}, context{isolate}, strict{strict} {}
+
+		HandleCastArguments(const v8::FunctionCallbackInfo<v8::Value>& info) : // NOLINT(hicpp-explicit-conversions)
+			HandleCastArguments{true, info.GetIsolate()} {}
+
+		HandleCastArguments(const v8::PropertyCallbackInfo<v8::Value>& info) : // NOLINT(hicpp-explicit-conversions)
+			HandleCastArguments{true, info.GetIsolate()} {}
+
+		HandleCastArguments(const v8::PropertyCallbackInfo<void>& info) : // NOLINT(hicpp-explicit-conversions)
+			HandleCastArguments{true, info.GetIsolate()} {}
+
+		v8::Isolate* const isolate;
+		const ContextHolder context;
+		const bool strict;
+};
+
+// Helper
+template <class Type>
+struct HandleCastTag {};
+
+// Explicit casts: printf("%d\n", HandleCastImpl<int>(value));
+template <class Type, class Value>
+auto HandleCast(Value&& value, HandleCastArguments arguments = {}) -> Type {
+	return HandleCastImpl(std::forward<Value>(value), arguments, HandleCastTag<Type>{});
+}
+
+// Identity cast
+template <class Type>
+inline auto HandleCastImpl(Type value, const HandleCastArguments& /*arguments*/, HandleCastTag<Type> /*tag*/) {
+	return value;
+}
+
+// Local<Value> -> Local<...> conversions
+inline auto HandleCastImpl(v8::Local<v8::Value> value, const HandleCastArguments& /*arguments*/, HandleCastTag<v8::Local<v8::Array>> /*tag*/) {
+	if (value->IsArray()) {
+		return value.As<v8::Array>();
+	}
+	ParamIncorrect::Throw("an array");
+}
+
+inline auto HandleCastImpl(v8::Local<v8::Value> value, const HandleCastArguments& arguments, HandleCastTag<v8::Local<v8::Boolean>> /*tag*/) {
+	if (value->IsBoolean()) {
+		return value.As<v8::Boolean>();
+	} else if (!arguments.strict) {
+		return value->ToBoolean(arguments.isolate);
+	}
+	ParamIncorrect::Throw("a boolean");
+}
+
+inline auto HandleCastImpl(v8::Local<v8::Value> value, const HandleCastArguments& /*arguments*/, HandleCastTag<v8::Local<v8::Function>> /*tag*/) {
+	if (value->IsFunction()) {
+		return value.As<v8::Function>();
+	}
+	ParamIncorrect::Throw("a function");
+}
+
+inline auto HandleCastImpl(v8::Local<v8::Value> value, const HandleCastArguments& /*arguments*/, HandleCastTag<v8::Local<v8::Int32>> /*tag*/) {
+	if (value->IsInt32()) {
+		return value.As<v8::Int32>();
+	}
+	ParamIncorrect::Throw("a 32-bit number");
+}
+
+inline auto HandleCastImpl(v8::Local<v8::Value> value, const HandleCastArguments& /*arguments*/, HandleCastTag<v8::Local<v8::Uint32>> /*tag*/) {
+	if (value->IsUint32()) {
+		return value.As<v8::Uint32>();
+	}
+	ParamIncorrect::Throw("a 32-bit number");
+}
+
+inline auto HandleCastImpl(v8::Local<v8::Value> value, const HandleCastArguments& /*arguments*/, HandleCastTag<v8::Local<v8::Number>> /*tag*/) {
+	if (value->IsNumber()) {
+		return value.As<v8::Number>();
+	}
+	ParamIncorrect::Throw("a number");
+}
+
+inline auto HandleCastImpl(v8::Local<v8::Value> value, const HandleCastArguments& /*arguments*/, HandleCastTag<v8::Local<v8::Object>> /*tag*/) {
+	if (value->IsObject()) {
+		return value.As<v8::Object>();
+	}
+	ParamIncorrect::Throw("an object");
+}
+
+inline auto HandleCastImpl(v8::Local<v8::Value> value, const HandleCastArguments& arguments, HandleCastTag<v8::Local<v8::String>> /*tag*/) {
+	if (value->IsString()) {
+		return value.As<v8::String>();
+	} else if (!arguments.strict) {
+		return Unmaybe(value->ToString(arguments.context));
+	}
+	ParamIncorrect::Throw("a string");
+}
+
+// Local<Value> -> MaybeLocal<...> conversions
+inline auto HandleCastImpl(v8::Local<v8::Value> value, const HandleCastArguments& /*arguments*/, HandleCastTag<v8::MaybeLocal<v8::Array>> /*tag*/)
+-> v8::MaybeLocal<v8::Array> {
+	if (value->IsNullOrUndefined()) {
+		return {};
+	} else if (value->IsArray()) {
+		return {value.As<v8::Array>()};
+	}
+	ParamIncorrect::Throw("an array");
+}
+
+inline auto HandleCastImpl(v8::Local<v8::Value> value, const HandleCastArguments& /*arguments*/, HandleCastTag<v8::MaybeLocal<v8::Function>> /*tag*/)
+-> v8::MaybeLocal<v8::Function> {
+	if (value->IsNullOrUndefined()) {
+		return {};
+	} else if (value->IsFunction()) {
+		return {value.As<v8::Function>()};
+	}
+	ParamIncorrect::Throw("a function");
+}
+
+inline auto HandleCastImpl(v8::Local<v8::Value> value, const HandleCastArguments& /*arguments*/, HandleCastTag<v8::MaybeLocal<v8::Object>> /*tag*/)
+-> v8::MaybeLocal<v8::Object> {
+	if (value->IsNullOrUndefined()) {
+		return {};
+	} else if (value->IsObject()) {
+		return {value.As<v8::Object>()};
+	}
+	ParamIncorrect::Throw("an object");
+}
+
+inline auto HandleCastImpl(v8::Local<v8::Value> value, const HandleCastArguments& arguments, HandleCastTag<v8::MaybeLocal<v8::String>> /*tag*/)
+-> v8::MaybeLocal<v8::String> {
+	if (value->IsNullOrUndefined()) {
+		return {};
+	} else if (value->IsString()) {
+		return {value.As<v8::String>()};
+	} else if (!arguments.strict) {
+		return {Unmaybe(value->ToString(arguments.context))};
+	}
+	ParamIncorrect::Throw("a string");
+}
+
+inline auto HandleCastImpl(v8::Local<v8::Value> value, const HandleCastArguments& /*arguments*/, HandleCastTag<v8::MaybeLocal<v8::Value>> /*tag*/) {
+	return v8::MaybeLocal<v8::Value>{value};
+}
+
+// Local<...> -> native C++ conversions
+inline auto HandleCastImpl(v8::Local<v8::Value> value, const HandleCastArguments& arguments, HandleCastTag<bool> /*tag*/) {
+	return HandleCast<bool>(HandleCast<v8::Local<v8::Boolean>>(value, arguments), arguments);
+}
+
+inline auto HandleCastImpl(v8::Local<v8::Boolean> value, const HandleCastArguments& /*arguments*/, HandleCastTag<bool> /*tag*/) {
+	return value->Value();
+}
+
+inline auto HandleCastImpl(v8::Local<v8::Value> value, const HandleCastArguments& arguments, HandleCastTag<double> /*tag*/) {
+	return HandleCast<double>(HandleCast<v8::Local<v8::Number>>(value, arguments), arguments);
+}
+
+inline auto HandleCastImpl(v8::Local<v8::Number> value, const HandleCastArguments& /*arguments*/, HandleCastTag<double> /*tag*/) {
+	return value->Value();
+}
+
+inline auto HandleCastImpl(v8::Local<v8::Value> value, const HandleCastArguments& arguments, HandleCastTag<int32_t> /*tag*/) {
+	return HandleCast<int32_t>(HandleCast<v8::Local<v8::Int32>>(value, arguments), arguments);
+}
+
+inline auto HandleCastImpl(v8::Local<v8::Int32> value, const HandleCastArguments& /*arguments*/, HandleCastTag<int32_t> /*tag*/) {
+	return value->Value();
+}
+
+inline auto HandleCastImpl(v8::Local<v8::Value> value, const HandleCastArguments& arguments, HandleCastTag<uint32_t> /*tag*/) {
+	return HandleCast<uint32_t>(HandleCast<v8::Local<v8::Uint32>>(value, arguments), arguments);
+}
+
+inline auto HandleCastImpl(v8::Local<v8::Uint32> value, const HandleCastArguments& /*arguments*/, HandleCastTag<uint32_t> /*tag*/) {
+	return value->Value();
+}
+
+inline auto HandleCastImpl(v8::Local<v8::Value> value, const HandleCastArguments& arguments, HandleCastTag<std::string> /*tag*/) {
+	return HandleCast<std::string>(HandleCast<v8::Local<v8::String>>(value, arguments), arguments);
+}
+
+inline auto HandleCastImpl(v8::Local<v8::String> value, const HandleCastArguments& arguments, HandleCastTag<std::string> /*tag*/) {
+	v8::String::Utf8Value utf8_value{arguments.isolate, value};
+	return std::string{*utf8_value, static_cast<size_t>(utf8_value.length())};
+}
+
+// native C++ -> Local<Value> conversions
+inline auto HandleCastImpl(bool value, const HandleCastArguments& arguments, HandleCastTag<v8::Local<v8::Boolean>> /*tag*/) {
+	return v8::Boolean::New(arguments.isolate, value);
+}
+
+inline auto HandleCastImpl(int32_t value, const HandleCastArguments& arguments, HandleCastTag<v8::Local<v8::Integer>> /*tag*/) {
+	return v8::Integer::New(arguments.isolate, value);
+}
+
+inline auto HandleCastImpl(uint32_t value, const HandleCastArguments& arguments, HandleCastTag<v8::Local<v8::Integer>> /*tag*/) {
+	return v8::Integer::NewFromUnsigned(arguments.isolate, value);
+}
+
+inline auto HandleCastImpl(int64_t value, const HandleCastArguments& arguments, HandleCastTag<v8::Local<v8::BigInt>> /*tag*/) {
+	return v8::BigInt::New(arguments.isolate, value);
+}
+
+inline auto HandleCastImpl(uint64_t value, const HandleCastArguments& arguments, HandleCastTag<v8::Local<v8::BigInt>> /*tag*/) {
+	return v8::BigInt::NewFromUnsigned(arguments.isolate, value);
+}
+
+inline auto HandleCastImpl(double value, const HandleCastArguments& arguments, HandleCastTag<v8::Local<v8::Number>> /*tag*/) {
+	return v8::Number::New(arguments.isolate, value);
+}
+
+inline auto HandleCastImpl(const char* value, const HandleCastArguments& arguments, HandleCastTag<v8::Local<v8::String>> /*tag*/) {
+	return Unmaybe(v8::String::NewFromUtf8(arguments.isolate, value, v8::NewStringType::kNormal));
+}
+
+inline auto HandleCastImpl(const std::string& value, const HandleCastArguments& arguments, HandleCastTag<v8::Local<v8::String>> /*tag*/) {
+	return Unmaybe(v8::String::NewFromUtf8(arguments.isolate, value.c_str(), v8::NewStringType::kNormal, value.size()));
+}
+
+} // namespace ivm

package/dist/node_modules/isolated-vm/src/isolate/generic/read_option.h

@@ -0,0 +1,47 @@
+#pragma once
+#include <v8.h>
+#include "handle_cast.h"
+
+namespace ivm {
+namespace detail {
+
+struct ParamRequired : std::exception {};
+
+template <class Type, class Property, class Default>
+inline auto ReadOptionImpl(v8::MaybeLocal<v8::Object> maybe_options, Property&& property, Default default_fn) {
+	HandleCastArguments arguments;
+	auto property_handle = HandleCast<v8::Local<v8::String>>(std::forward<Property>(property), arguments);
+	try {
+		v8::Local<v8::Object> options;
+		if (maybe_options.ToLocal(&options)) {
+			v8::Local<v8::Value> value = Unmaybe(options->Get(arguments.context, property_handle));
+			if (value->IsNullOrUndefined()) {
+				return default_fn();
+			}
+			return HandleCast<Type>(value, arguments);
+		} else {
+			return default_fn();
+		}
+	} catch (const ParamIncorrect& ex) {
+		throw RuntimeTypeError{
+			std::string{"`"}+ *v8::String::Utf8Value{arguments.isolate, property_handle}+ "` must be "+ ex.type
+		};
+	} catch (const ParamRequired&) {
+		throw RuntimeTypeError(
+			std::string{"`"}+ *v8::String::Utf8Value{arguments.isolate, property_handle}+ "` is required");
+	}
+}
+
+} // namespace detail
+
+template <class Type, class Options, class Property>
+auto ReadOption(Options options, Property&& property) {
+	return detail::ReadOptionImpl<Type>(options, std::forward<Property>(property), []() { throw detail::ParamRequired(); });
+}
+
+template <class Type, class Options, class Property>
+auto ReadOption(Options options, Property&& property, Type default_value) {
+	return detail::ReadOptionImpl<Type>(options, std::forward<Property>(property), [&]() { return std::move(default_value); });
+}
+
+}

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

@@ -0,0 +1,88 @@
+#include "holder.h"
+#include "environment.h"
+#include "scheduler.h"
+#include "util.h"
+#include "lib/timer.h"
+#include <utility>
+
+namespace ivm {
+
+void IsolateDisposeWait::IsolateDidDispose() {
+	*is_disposed.write() = true;
+	is_disposed.notify_all();
+}
+
+void IsolateDisposeWait::Join() {
+	auto lock = is_disposed.read<true>();
+	while (!*lock) {
+		lock.wait();
+	}
+}
+
+auto IsolateHolder::GetCurrent() -> std::shared_ptr<IsolateHolder> {
+	return IsolateEnvironment::GetCurrentHolder();
+}
+
+auto IsolateHolder::Dispose() -> bool {
+	auto ref = std::exchange(*isolate.write(), {});
+	if (ref) {
+		ref->Terminate();
+		ref.reset();
+		return true;
+	} else {
+		return false;
+	}
+}
+
+void IsolateHolder::Release() {
+	auto ref = std::exchange(*isolate.write(), {});
+	ref.reset();
+}
+
+auto IsolateHolder::GetIsolate() -> std::shared_ptr<IsolateEnvironment> {
+	return *isolate.read();
+}
+
+void IsolateHolder::ScheduleTask(std::unique_ptr<Runnable> task, bool run_inline, bool wake_isolate, bool handle_task) {
+	auto ref = *isolate.read();
+	if (ref) {
+		if (run_inline && Executor::MayRunInlineTasks(*ref)) {
+			task->Run();
+			return;
+		}
+		auto lock = ref->scheduler->Lock();
+		if (handle_task) {
+			lock->handle_tasks.push(std::move(task));
+		} else {
+			lock->tasks.push(std::move(task));
+		}
+		if (wake_isolate) {
+			lock->WakeIsolate(std::move(ref));
+		}
+	}
+}
+
+// Methods for v8::TaskRunner
+void IsolateTaskRunner::PostTask(std::unique_ptr<v8::Task> task) {
+	auto env = weak_env.lock();
+	if (env) {
+		env->GetScheduler().Lock()->tasks.push(std::move(task));
+	}
+}
+
+void IsolateTaskRunner::PostDelayedTask(std::unique_ptr<v8::Task> task, double delay_in_seconds) {
+	// wait_detached erases the type of the lambda into a std::function which must be
+	// copyable. The unique_ptr is stored in a shared pointer so ownership can be handled correctly.
+	auto shared_task = std::make_shared<std::unique_ptr<v8::Task>>(std::move(task));
+	auto weak_env = this->weak_env;
+	timer_t::wait_detached(static_cast<uint32_t>(delay_in_seconds * 1000), [shared_task, weak_env](void* next) {
+		auto env = weak_env.lock();
+		if (env) {
+			// Don't wake the isolate, this will just run the next time the isolate is doing something
+			env->GetScheduler().Lock()->tasks.push(std::move(*shared_task));
+		}
+		timer_t::chain(next);
+	});
+}
+
+} // namespace ivm

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

@@ -0,0 +1,63 @@
+#pragma once
+#include "platform_delegate.h"
+#include "runnable.h"
+#include "v8_version.h"
+#include "lib/lockable.h"
+#include <v8-platform.h>
+#include <condition_variable>
+#include <mutex>
+#include <memory>
+
+namespace ivm {
+
+class IsolateEnvironment;
+
+class IsolateDisposeWait {
+	public:
+		void IsolateDidDispose();
+		void Join();
+
+	private:
+		lockable_t<bool, false, true> is_disposed{false};
+};
+
+class IsolateHolder {
+	friend IsolateEnvironment;
+
+	public:
+		explicit IsolateHolder(std::shared_ptr<IsolateEnvironment> isolate) :
+			isolate{std::move(isolate)} {}
+		IsolateHolder(const IsolateHolder&) = delete;
+		~IsolateHolder() = default;
+		auto operator=(const IsolateHolder&) = delete;
+
+		static auto GetCurrent() -> std::shared_ptr<IsolateHolder>;
+
+		auto Dispose() -> bool;
+		void Release();
+		auto GetIsolate() -> std::shared_ptr<IsolateEnvironment>;
+		void ScheduleTask(std::unique_ptr<Runnable> task, bool run_inline, bool wake_isolate, bool handle_task = false);
+
+	private:
+		lockable_t<std::shared_ptr<IsolateEnvironment>> isolate;
+};
+
+// This needs to be separate from IsolateHolder because v8 holds references to this indefinitely and
+// we don't want it keeping the isolate alive.
+class IsolateTaskRunner final : public TaskRunner {
+	public:
+		explicit IsolateTaskRunner(const std::shared_ptr<IsolateEnvironment>& isolate) : weak_env{isolate} {}
+		IsolateTaskRunner(const IsolateTaskRunner&) = delete;
+		~IsolateTaskRunner() final = default;
+		auto operator=(const IsolateTaskRunner&) = delete;
+
+		// Methods for v8::TaskRunner
+		void PostTask(std::unique_ptr<v8::Task> task) final;
+		void PostDelayedTask(std::unique_ptr<v8::Task> task, double delay_in_seconds) final;
+		void PostNonNestableTask(std::unique_ptr<v8::Task> task) final { PostTask(std::move(task)); }
+
+	private:
+		std::weak_ptr<IsolateEnvironment> weak_env;
+};
+
+} // namespace ivm

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

@@ -0,0 +1,200 @@
+#include "inspector.h"
+#include "environment.h"
+#include "runnable.h"
+#include "util.h"
+#include "lib/timer.h"
+#include <string>
+
+using namespace ivm;
+using namespace v8;
+using namespace v8_inspector;
+using std::shared_ptr;
+using std::unique_ptr;
+
+namespace ivm {
+
+/**
+ * This constructor will be called from a non-locked thread.
+ */
+InspectorAgent::InspectorAgent(IsolateEnvironment& isolate) : isolate(isolate), inspector(V8Inspector::create(isolate, this)) {
+	struct AddDefaultContext : public Runnable {
+		InspectorAgent& that;
+		explicit AddDefaultContext(InspectorAgent& agent) : that(agent) {}
+		void Run() final {
+			// We can assume that agent is still alive because otherwise this won't get called
+			that.ContextCreated(that.isolate.DefaultContext(), "default");
+		}
+	};
+	SendInterrupt(std::make_unique<AddDefaultContext>(*this));
+}
+
+/**
+ * Called right before the isolate is disposed.
+ */
+InspectorAgent::~InspectorAgent() {
+	auto sessions_lock = active_sessions.write();
+	for (auto ii = sessions_lock->begin(); ii != sessions_lock->end(); ) {
+		InspectorSession* session = *ii;
+		++ii;
+		session->Disconnect();
+	}
+	assert(sessions_lock->empty());
+}
+
+/**
+ * When debugging running JS code this function is called and is expected to block and process
+ * inspector messages until the inspector is done. This happens in the isolate's currently running
+ * thread so we know that an Executor::Lock is up.
+ */
+void InspectorAgent::runMessageLoopOnPause(int /*context_group_id*/) {
+	if (terminated) {
+		return;
+	}
+	Executor::PauseScope pause_cpu_timer{isolate.executor.cpu_timer};
+	std::unique_lock<std::mutex> lock{mutex};
+	running = true;
+	do {
+		cv.wait(lock);
+		lock.unlock();
+		{
+			Executor::UnpauseScope unpause_cpu_timer{pause_cpu_timer};
+			isolate.InterruptEntryAsync();
+		}
+		lock.lock();
+	} while (running && !terminated);
+}
+
+/**
+ * This is the notificaiton to exit from the currently running `runMessageLoopOnPause` from another
+ * thread.
+ */
+void InspectorAgent::quitMessageLoopOnPause() {
+	// This is called from within runMessageLoopOnPause, therefore lock is already acquired
+	running = false;
+	cv.notify_all();
+}
+
+/**
+ * Connects a V8Inspector::Channel to a V8Inspector which returns an instance of V8InspectorSession.
+ */
+auto InspectorAgent::ConnectSession(InspectorSession& session) -> unique_ptr<V8InspectorSession> {
+	active_sessions.write()->insert(&session);
+#if V8_AT_LEAST(10, 3, 118)
+	return inspector->connect(1, &session, StringView(), v8_inspector::V8Inspector::ClientTrustLevel::kFullyTrusted);
+#else
+	return inspector->connect(1, &session, StringView());
+#endif
+}
+
+/**
+ * Called from the session when it disconnects.
+ */
+void InspectorAgent::SessionDisconnected(InspectorSession& session) {
+	assert(active_sessions.write()->erase(&session) == 1);
+}
+
+/**
+ * Request to send an interrupt to the inspected isolate
+ */
+void InspectorAgent::SendInterrupt(unique_ptr<Runnable> task) {
+	// If this isolate is already locked just run the task. This happens at least when the isolate is disposing
+	// and `holder` no longer has a valid shared_ptr
+	if (Executor::GetCurrentEnvironment() == &isolate) {
+		task->Run();
+		return;
+	}
+	// Grab pointer because it's needed for WakeIsolate
+	auto holder = isolate.holder.lock();
+	assert(holder);
+	auto ptr = holder->GetIsolate();
+	assert(ptr);
+	// Push interrupt onto queue
+	auto scheduler_lock = isolate.scheduler->Lock();
+	scheduler_lock->interrupts.push(std::move(task));
+	// Wake up the isolate
+	if (!scheduler_lock->WakeIsolate(ptr)) { // `true` if isolate is inactive
+		// Isolate is currently running
+		std::lock_guard<std::mutex> lock{mutex};
+		if (running) {
+			// Isolate is being debugged and is in `runMessageLoopOnPause`
+			cv.notify_all();
+		} else {
+			// Isolate is busy running JS code
+			scheduler_lock->InterruptIsolate();
+		}
+	}
+}
+
+/**
+ * Hook to add context to agent.
+ */
+void InspectorAgent::ContextCreated(Local<Context> context, const std::string& name) {
+	inspector->contextCreated(V8ContextInfo(context, 1, StringView(reinterpret_cast<const uint8_t*>(name.c_str()), name.length())));
+}
+
+/**
+ * Hook to remove context from agent.
+ */
+void InspectorAgent::ContextDestroyed(Local<Context> context) {
+	inspector->contextDestroyed(context);
+}
+
+/**
+ * Called when this isolate needs to dispose, disables all inspector activity
+ */
+void InspectorAgent::Terminate() {
+	std::lock_guard<std::mutex> lock(mutex);
+	terminated = true;
+	cv.notify_all();
+}
+
+/**
+ * Creates a new session and connects it to a given agent.
+ */
+InspectorSession::InspectorSession(IsolateEnvironment& isolate) : agent(*isolate.GetInspectorAgent()), session(agent.ConnectSession(*this)) {}
+
+InspectorSession::~InspectorSession() {
+	Disconnect();
+}
+
+/**
+ * Disconnects this session from the v8 inspector. Allows inspector to deallocate gracefully.
+ */
+void InspectorSession::Disconnect() {
+	std::lock_guard<std::mutex> lock(mutex);
+	if (session) {
+		agent.SessionDisconnected(*this);
+		struct DeleteSession : public Runnable {
+			shared_ptr<V8InspectorSession> session;
+			explicit DeleteSession(shared_ptr<V8InspectorSession> session) : session(std::move(session)) {}
+			// Nothing is needed since the dtor will (should) delete the session in the right context
+			void Run() final {}
+		};
+		agent.SendInterrupt(std::make_unique<DeleteSession>(std::move(session)));
+	}
+}
+
+/**
+ * Send a message from this session to the backend.
+ */
+void InspectorSession::DispatchBackendProtocolMessage(std::vector<uint16_t> message) {
+	std::lock_guard<std::mutex> lock(mutex);
+	if (session) {
+		struct DispatchMessage : public Runnable {
+			std::vector<uint16_t> message;
+			std::weak_ptr<V8InspectorSession> weak_session;
+			explicit DispatchMessage(std::vector<uint16_t> message, shared_ptr<V8InspectorSession>& session) : message(std::move(message)), weak_session(session) {}
+			void Run() final {
+				auto session = weak_session.lock();
+				if (session) {
+					session->dispatchProtocolMessage(StringView(&message[0], message.size()));
+				}
+			}
+		};
+		agent.SendInterrupt(std::make_unique<DispatchMessage>(std::move(message), session));
+	} else {
+		throw RuntimeGenericError("Session is dead");
+	}
+}
+
+} // namespace ivm