// Start a watchdog thread for calling v8::Debug::DebugBreak() because

// it's not safe to call directly from the signal handler, it can

// deadlock with the thread it interrupts.

CHECK_EQ(0, uv_sem_init(&start_io_thread_semaphore, 0));

pthread_attr_t attr;

CHECK_EQ(0, pthread_attr_init(&attr));

#if defined(PTHREAD_STACK_MIN) && !defined(__FreeBSD__)

// PTHREAD_STACK_MIN is 2 KiB with musl libc, which is too small to safely

// receive signals. PTHREAD_STACK_MIN + MINSIGSTKSZ is 8 KiB on arm64, which

// is the musl architecture with the biggest MINSIGSTKSZ so let's use that

// as a lower bound and let's quadruple it just in case. The goal is to avoid

// creating a big 2 or 4 MiB address space gap (problematic on 32 bits

// because of fragmentation), not squeeze out every last byte.

// Omitted on FreeBSD because it doesn't seem to like small stacks.

const size_t stack_size = std::max(static_cast<size_t>(4 * 8192),

static_cast<size_t>(PTHREAD_STACK_MIN));

CHECK_EQ(0, pthread_attr_setstacksize(&attr, stack_size));

#endif // defined(PTHREAD_STACK_MIN) && !defined(__FreeBSD__)

CHECK_EQ(0, pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED));

sigset_t sigmask;

// Mask all signals.

sigfillset(&sigmask);

sigset_t savemask;

CHECK_EQ(0, pthread_sigmask(SIG_SETMASK, &sigmask, &savemask));

sigmask = savemask;

pthread_t thread;

const int err = pthread_create(&thread, &attr, StartIoThreadMain, nullptr);

CHECK_EQ(0, pthread_attr_destroy(&attr));

if (err != 0) {

// Restore original mask

CHECK_EQ(0, pthread_sigmask(SIG_SETMASK, &sigmask, nullptr));

fprintf(stderr, "node[%u]: pthread_create: %s\n",

uv_os_getpid(), strerror(err));

fflush(stderr);

uv_sem_destroy(&start_io_thread_semaphore);

return -err;

}

RegisterSignalHandler(SIGUSR1, StartIoThreadWakeup);

// Restore original mask

CHECK_EQ(0, pthread_sigmask(SIG_SETMASK, &sigmask, nullptr));

return 0;

{

Mutex::ScopedLock lock(start_io_thread_agents_mutex);

if (!debug_signal_handler_started) {

// Leave SIGUSR1 blocked on failure. We don't install a signal handler,

// receiving the signal would terminate the process.

if (int err = StartWatchdogThread()) return err;

debug_signal_handler_started = true;

}

}

// Unblock SIGUSR1 on this thread; PlatformInit() left it blocked. A pending

// SIGUSR1 signal will now be delivered.

sigset_t sigmask;

sigemptyset(&sigmask);

sigaddset(&sigmask, SIGUSR1);

CHECK_EQ(0, pthread_sigmask(SIG_UNBLOCK, &sigmask, nullptr));

return 0;

Mutex::ScopedLock lock(start_io_thread_agents_mutex);

if (debug_signal_handler_started) return 0;

debug_signal_handler_started = true;

wchar_t mapping_name[32];

HANDLE mapping_handle;

DWORD pid;

LPTHREAD_START_ROUTINE* handler;

pid = uv_os_getpid();

if (GetDebugSignalHandlerMappingName(pid,

mapping_name,

arraysize(mapping_name)) < 0) {

return -1;

}

mapping_handle = CreateFileMappingW(INVALID_HANDLE_VALUE,

nullptr,

PAGE_READWRITE,

0,

sizeof *handler,

mapping_name);

if (mapping_handle == nullptr) {

return -1;

}

handler = reinterpret_cast<LPTHREAD_START_ROUTINE*>(

MapViewOfFile(mapping_handle,

FILE_MAP_ALL_ACCESS,

0,

0,

sizeof *handler));

if (handler == nullptr) {

CloseHandle(mapping_handle);

return -1;

}

*handler = StartIoThreadProc;

UnmapViewOfFile(static_cast<void*>(handler));

return 0;

std::ostringstream result;

result << "Worker[" << env->thread_id() << "]";

return result.str();

public protocol::FrontendChannel {

public:

explicit ChannelImpl(Environment* env,

const std::unique_ptr<V8Inspector>& inspector,

std::shared_ptr<WorkerManager> worker_manager,

std::unique_ptr<InspectorSessionDelegate> delegate,

std::shared_ptr<MainThreadHandle> main_thread,

bool prevent_shutdown)

: delegate_(std::move(delegate)),

main_thread_(main_thread),

env_(env),

prevent_shutdown_(prevent_shutdown),

retaining_context_(false) {

session_ = inspector->connect(CONTEXT_GROUP_ID,

this,

StringView(),

V8Inspector::ClientTrustLevel::kFullyTrusted);

node_dispatcher_ = std::make_unique<UberDispatcher>(this);

#ifndef V8_USE_PERFETTO

tracing_agent_ =

std::make_unique<protocol::TracingAgent>(env, main_thread_);

tracing_agent_->Wire(node_dispatcher_.get());

#endif // V8_USE_PERFETTO

if (worker_manager) {

worker_agent_ = std::make_unique<protocol::WorkerAgent>(worker_manager);

worker_agent_->Wire(node_dispatcher_.get());

}

runtime_agent_ = std::make_unique<protocol::RuntimeAgent>();

runtime_agent_->Wire(node_dispatcher_.get());

if (env->options()->experimental_inspector_network_resource) {

io_agent_ = std::make_unique<protocol::IoAgent>(

env->inspector_agent()->GetNetworkResourceManager());

io_agent_->Wire(node_dispatcher_.get());

network_inspector_ = std::make_unique<NetworkInspector>(

env,

inspector.get(),

env->inspector_agent()->GetNetworkResourceManager());

} else {

network_inspector_ =

std::make_unique<NetworkInspector>(env, inspector.get(), nullptr);

}

network_inspector_->Wire(node_dispatcher_.get());

if (env->options()->experimental_worker_inspection) {

target_agent_ = std::make_shared<protocol::TargetAgent>();

target_agent_->Wire(node_dispatcher_.get());

target_agent_->listenWorker(worker_manager);

}

if (env->options()->experimental_storage_inspection) {

dom_storage_agent_ = std::make_unique<DOMStorageAgent>(env);

dom_storage_agent_->Wire(node_dispatcher_.get());

storage_agent_ = std::make_unique<protocol::StorageAgent>(env_);

storage_agent_->Wire(node_dispatcher_.get());

}

}

~ChannelImpl() override {

#ifndef V8_USE_PERFETTO

tracing_agent_->disable();

tracing_agent_.reset(); // Dispose before the dispatchers

#endif // V8_USE_PERFETTO

if (worker_agent_) {

worker_agent_->disable();

worker_agent_.reset(); // Dispose before the dispatchers

}

runtime_agent_->disable();

runtime_agent_.reset(); // Dispose before the dispatchers

network_inspector_->Disable();

network_inspector_.reset(); // Dispose before the dispatchers

if (target_agent_) {

target_agent_->reset();

}

if (storage_agent_) {

storage_agent_->disable();

storage_agent_.reset();

}

if (dom_storage_agent_) {

dom_storage_agent_->disable();

dom_storage_agent_.reset();

}

}

void emitNotificationFromBackend(v8::Local<v8::Context> context,

const StringView& event,

Local<Object> params) {

std::string raw_event = protocol::StringUtil::StringViewToUtf8(event);

std::string domain_name = raw_event.substr(0, raw_event.find('.'));

std::string event_name = raw_event.substr(raw_event.find('.') + 1);

if (network_inspector_->canEmit(domain_name) &&

env_->options()->experimental_network_inspection) {

network_inspector_->emitNotification(

context, domain_name, event_name, params);

} else if (dom_storage_agent_ && dom_storage_agent_->canEmit(domain_name) &&

env_->options()->experimental_storage_inspection) {

dom_storage_agent_->emitNotification(context, event_name, params);

}

}

void dispatchProtocolMessage(const StringView& message) {

std::string raw_message = protocol::StringUtil::StringViewToUtf8(message);

per_process::Debug(DebugCategory::INSPECTOR_SERVER,

"[inspector received] %s\n",

raw_message);

std::vector<uint8_t> cbor_buffer;

ConvertJSONToCBOR(crdtp::SpanFrom(raw_message), &cbor_buffer);

Dispatchable dispatchable(crdtp::SpanFrom(cbor_buffer));

crdtp::span<uint8_t> method = dispatchable.Method();

if (v8_inspector::V8InspectorSession::canDispatchMethod(

StringView(method.data(), method.size()))) {

session_->dispatchProtocolMessage(message);

return;

}

UberDispatcher::DispatchResult result =

node_dispatcher_->Dispatch(dispatchable);

if (!result.MethodFound()) {

per_process::Debug(DebugCategory::INSPECTOR_SERVER,

"[inspector] method not found\n");

// Fall through to send a method not found error.

}

result.Run();

}

void schedulePauseOnNextStatement(const std::string& reason) {

std::unique_ptr<StringBuffer> buffer = Utf8ToStringView(reason);

session_->schedulePauseOnNextStatement(buffer->string(), buffer->string());

}

bool preventShutdown() {

return prevent_shutdown_;

}

bool notifyWaitingForDisconnect() {

retaining_context_ = runtime_agent_->notifyWaitingForDisconnect();

return retaining_context_;

}

void setWaitingForDebugger() { runtime_agent_->setWaitingForDebugger(); }

void unsetWaitingForDebugger() { runtime_agent_->unsetWaitingForDebugger(); }

bool retainingContext() {

return retaining_context_;

}

private:

// v8_inspector::V8Inspector::Channel

void sendResponse(

int callId,

std::unique_ptr<v8_inspector::StringBuffer> message) override {

sendMessageToFrontend(message->string());

}

// v8_inspector::V8Inspector::Channel

void sendNotification(

std::unique_ptr<v8_inspector::StringBuffer> message) override {

sendMessageToFrontend(message->string());

}

// v8_inspector::V8Inspector::Channel

void flushProtocolNotifications() override { }

// crdtp::FrontendChannel

void FlushProtocolNotifications() override {}

std::string serializeToJSON(std::unique_ptr<Serializable> message) {

std::vector<uint8_t> cbor = message->Serialize();

std::string json;

crdtp::Status status = ConvertCBORToJSON(crdtp::SpanFrom(cbor), &json);

CHECK(status.ok());

USE(status);

return json;

}

void sendMessageToFrontend(const StringView& message) {

if (per_process::enabled_debug_list.enabled(

DebugCategory::INSPECTOR_SERVER)) {

std::string raw_message = protocol::StringUtil::StringViewToUtf8(message);

per_process::Debug(DebugCategory::INSPECTOR_SERVER,

"[inspector send] %s\n",

raw_message);

}

std::optional<int> target_session_id = main_thread_->GetTargetSessionId();

if (target_session_id.has_value()) {

std::string raw_message = protocol::StringUtil::StringViewToUtf8(message);

std::unique_ptr<protocol::DictionaryValue> value =

protocol::DictionaryValue::cast(JsonUtil::parseJSON(raw_message));

std::string target_session_id_str = std::to_string(*target_session_id);

value->setString("sessionId", target_session_id_str);

std::string json = serializeToJSON(std::move(value));

delegate_->SendMessageToFrontend(Utf8ToStringView(json)->string());

} else {

delegate_->SendMessageToFrontend(message);

}

}

void sendMessageToFrontend(const std::string& message) {

sendMessageToFrontend(Utf8ToStringView(message)->string());

}

// crdtp::FrontendChannel

void SendProtocolResponse(int callId,

std::unique_ptr<Serializable> message) override {

std::string json = serializeToJSON(std::move(message));

sendMessageToFrontend(json);

}

// crdtp::FrontendChannel

void SendProtocolNotification(

std::unique_ptr<Serializable> message) override {

std::string json = serializeToJSON(std::move(message));

sendMessageToFrontend(json);

}

// crdtp::FrontendChannel

void FallThrough(int call_id,

crdtp::span<uint8_t> method,

crdtp::span<uint8_t> message) override {

DCHECK(false);

}

std::unique_ptr<protocol::RuntimeAgent> runtime_agent_;

#ifndef V8_USE_PERFETTO

std::unique_ptr<protocol::TracingAgent> tracing_agent_;

#endif

std::unique_ptr<protocol::WorkerAgent> worker_agent_;

std::shared_ptr<protocol::TargetAgent> target_agent_;

std::unique_ptr<NetworkInspector> network_inspector_;

std::unique_ptr<DOMStorageAgent> dom_storage_agent_;

std::unique_ptr<protocol::StorageAgent> storage_agent_;

std::shared_ptr<protocol::IoAgent> io_agent_;

std::unique_ptr<InspectorSessionDelegate> delegate_;

std::unique_ptr<v8_inspector::V8InspectorSession> session_;

std::unique_ptr<UberDispatcher> node_dispatcher_;

std::shared_ptr<MainThreadHandle> main_thread_;

Environment* env_;

bool prevent_shutdown_;

bool retaining_context_;

public:

SameThreadInspectorSession(

int session_id, std::shared_ptr<NodeInspectorClient> client)

: session_id_(session_id), client_(client) {}

~SameThreadInspectorSession() override;

void Dispatch(const v8_inspector::StringView& message) override;

private:

int session_id_;

std::weak_ptr<NodeInspectorClient> client_;

Isolate* isolate = env->isolate();

HandleScope handle_scope(isolate);

// Send message to enable debug in cluster workers

Local<Name> name = FIXED_ONE_BYTE_STRING(isolate, "cmd");

Local<Value> value = FIXED_ONE_BYTE_STRING(isolate, "NODE_DEBUG_ENABLED");

Local<Object> message =

Object::New(isolate, Object::New(isolate), &name, &value, 1);

ProcessEmit(env, "internalMessage", message);

// '\\'

if (path.length() > 2 && path[0] == '\\' && path[1] == '\\')

return true;

// '[A-Z]:[/\\]'

if (path.length() < 3)

return false;

if ((path[0] >= 'A' && path[0] <= 'Z') || (path[0] >= 'a' && path[0] <= 'z'))

return path[1] == ':' && (path[2] == '/' || path[2] == '\\');

return false;

public:

explicit NodeInspectorClient(node::Environment* env, bool is_main)

: env_(env), is_main_(is_main) {

client_ = V8Inspector::create(env->isolate(), this);

// TODO(bnoordhuis) Make name configurable from src/node.cc.

std::string name =

is_main_ ? GetHumanReadableProcessName() : GetWorkerLabel(env);

ContextInfo info(name);

info.is_default = true;

contextCreated(env->context(), info);

}

void runMessageLoopOnPause(int context_group_id) override {

waiting_for_resume_ = true;

runMessageLoop();

}

void waitForSessionsDisconnect() {

waiting_for_sessions_disconnect_ = true;

runMessageLoop();

}

void waitForFrontend() {

waiting_for_frontend_ = true;

for (const auto& id_channel : channels_) {

id_channel.second->setWaitingForDebugger();

}

runMessageLoop();

}

void maxAsyncCallStackDepthChanged(int depth) override {

if (waiting_for_sessions_disconnect_) {

// V8 isolate is mostly done and is only letting Inspector protocol

// clients gather data.

return;

}

if (auto agent = env_->inspector_agent()) {

agent->SetAsyncHookTrackingEnabled(depth != 0);

}

}

void contextCreated(Local<Context> context, const ContextInfo& info) {

auto name_buffer = Utf8ToStringView(info.name);

auto origin_buffer = Utf8ToStringView(info.origin);

std::unique_ptr<StringBuffer> aux_data_buffer;

v8_inspector::V8ContextInfo v8info(

context, CONTEXT_GROUP_ID, name_buffer->string());

v8info.origin = origin_buffer->string();

if (info.is_default) {

aux_data_buffer = Utf8ToStringView("{\"isDefault\":true}");

} else {

aux_data_buffer = Utf8ToStringView("{\"isDefault\":false}");

}

v8info.auxData = aux_data_buffer->string();

client_->contextCreated(v8info);

}

void contextDestroyed(Local<Context> context) {

client_->contextDestroyed(context);

}

void quitMessageLoopOnPause() override {

waiting_for_resume_ = false;

}

void runIfWaitingForDebugger(int context_group_id) override {

waiting_for_frontend_ = false;

for (const auto& id_channel : channels_) {

id_channel.second->unsetWaitingForDebugger();

}

}

void StopIfWaitingForFrontendEvent() {

if (!waiting_for_frontend_) {

return;

}

waiting_for_frontend_ = false;

for (const auto& id_channel : channels_) {

id_channel.second->unsetWaitingForDebugger();

}

if (interface_) {

per_process::Debug(DebugCategory::INSPECTOR_CLIENT,

"Stopping waiting for frontend events\n");

interface_->StopWaitingForFrontendEvent();

}

}

int connectFrontend(std::unique_ptr<InspectorSessionDelegate> delegate,

bool prevent_shutdown) {

int session_id = next_session_id_++;

channels_[session_id] = std::make_unique<ChannelImpl>(env_,

client_,

getWorkerManager(),

std::move(delegate),

getThreadHandle(),

prevent_shutdown);

if (waiting_for_frontend_) {

channels_[session_id]->setWaitingForDebugger();

}

return session_id;

}

void disconnectFrontend(int session_id) {

auto it = channels_.find(session_id);

if (it == channels_.end())

return;

bool retaining_context = it->second->retainingContext();

channels_.erase(it);

if (retaining_context) {

for (const auto& id_channel : channels_) {

if (id_channel.second->retainingContext())

return;

}

contextDestroyed(env_->context());

}

if (waiting_for_sessions_disconnect_ && !is_main_)

waiting_for_sessions_disconnect_ = false;

}

void dispatchMessageFromFrontend(int session_id, const StringView& message) {

channels_[session_id]->dispatchProtocolMessage(message);

}

Local<Context> ensureDefaultContextInGroup(int contextGroupId) override {

return env_->context();

}

void installAdditionalCommandLineAPI(Local<Context> context,

Local<Object> target) override {

if (!env_->can_call_into_js()) return;

Local<Function> installer = env_->inspector_console_extension_installer();

if (!installer.IsEmpty()) {

Local<Value> argv[] = {target};

// If there is an exception, proceed in JS land

USE(installer->Call(context, target, arraysize(argv), argv));

}

}

void ReportUncaughtException(Local<Value> error, Local<Message> message) {

Isolate* isolate = env_->isolate();

Local<Context> context = env_->context();

int script_id = message->GetScriptOrigin().ScriptId();

Local<v8::StackTrace> stack_trace = message->GetStackTrace();

if (!stack_trace.IsEmpty() && stack_trace->GetFrameCount() > 0 &&

script_id == stack_trace->GetFrame(isolate, 0)->GetScriptId()) {

script_id = 0;

}

const uint8_t DETAILS[] = "Uncaught";

client_->exceptionThrown(

context,

StringView(DETAILS, sizeof(DETAILS) - 1),

error,

ToInspectorString(isolate, message->Get())->string(),

ToInspectorString(isolate, message->GetScriptResourceName())->string(),

message->GetLineNumber(context).FromMaybe(0),

message->GetStartColumn(),

client_->createStackTrace(stack_trace),

script_id);

}

void startRepeatingTimer(double interval_s,

TimerCallback callback,

void* data) override {

auto result =

timers_.emplace(std::piecewise_construct, std::make_tuple(data),

std::make_tuple(env_, [=]() { callback(data); }));

CHECK(result.second);

uint64_t interval = static_cast<uint64_t>(1000 * interval_s);

result.first->second.Update(interval, interval);

}

void cancelTimer(void* data) override {

timers_.erase(data);

}

// Async stack traces instrumentation.

void AsyncTaskScheduled(const StringView& task_name, void* task,

bool recurring) {

client_->asyncTaskScheduled(task_name, task, recurring);

}

void AsyncTaskCanceled(void* task) {

client_->asyncTaskCanceled(task);

}

void AsyncTaskStarted(void* task) {

client_->asyncTaskStarted(task);

}

void AsyncTaskFinished(void* task) {

client_->asyncTaskFinished(task);

}

void AllAsyncTasksCanceled() {

client_->allAsyncTasksCanceled();

}

void schedulePauseOnNextStatement(const std::string& reason) {

for (const auto& id_channel : channels_) {

id_channel.second->schedulePauseOnNextStatement(reason);

}

}

bool hasConnectedSessions() {

for (const auto& id_channel : channels_) {

// Other sessions are "invisible" more most purposes

if (id_channel.second->preventShutdown())

return true;

}

return false;

}

bool notifyWaitingForDisconnect() {

bool retaining_context = false;

for (const auto& id_channel : channels_) {

if (id_channel.second->notifyWaitingForDisconnect())

retaining_context = true;

}

return retaining_context;

}

void emitNotification(v8::Local<v8::Context> context,

const StringView& event,

Local<Object> params) {

for (const auto& id_channel : channels_) {

id_channel.second->emitNotificationFromBackend(context, event, params);

}

}

std::shared_ptr<MainThreadHandle> getThreadHandle() {

if (!interface_) {

interface_ = std::make_shared<MainThreadInterface>(

env_->inspector_agent());

}

return interface_->GetHandle();

}

std::shared_ptr<WorkerManager> getWorkerManager() {

if (!is_main_) {

return nullptr;

}

if (worker_manager_ == nullptr) {

worker_manager_ =

std::make_shared<WorkerManager>(getThreadHandle());

}

return worker_manager_;

}

bool IsActive() {

return !channels_.empty();

}

private:

bool shouldRunMessageLoop() {

if (waiting_for_frontend_)

return true;

if (waiting_for_sessions_disconnect_ || waiting_for_resume_) {

return hasConnectedSessions();

}

return false;

}

void runMessageLoop() {

if (running_nested_loop_)

return;

running_nested_loop_ = true;

per_process::Debug(DebugCategory::INSPECTOR_CLIENT,

"Entering nested loop\n");

while (shouldRunMessageLoop()) {

if (interface_) interface_->WaitForFrontendEvent();

env_->RunAndClearInterrupts();

}

running_nested_loop_ = false;

per_process::Debug(DebugCategory::INSPECTOR_CLIENT, "Exited nested loop\n");

}

double currentTimeMS() override {

MultiIsolatePlatform* platform = env_->isolate_data()->platform();

if (platform == nullptr) return GetCurrentTimeInMicroseconds() / 1000;

return platform->CurrentClockTimeMillis();

}

std::unique_ptr<StringBuffer> resourceNameToUrl(

const StringView& resource_name_view) override {

std::string resource_name =

protocol::StringUtil::StringViewToUtf8(resource_name_view);

if (!IsFilePath(resource_name))

return nullptr;

std::string url = node::url::FromFilePath(resource_name);

return Utf8ToStringView(url);

}

node::Environment* env_;

bool is_main_;

bool running_nested_loop_ = false;

std::unique_ptr<V8Inspector> client_;

// Note: ~ChannelImpl may access timers_ so timers_ has to come first.

std::unordered_map<void*, TimerWrapHandle> timers_;

std::unordered_map<int, std::unique_ptr<ChannelImpl>> channels_;

int next_session_id_ = 1;

bool waiting_for_resume_ = false;

bool waiting_for_frontend_ = false;

bool waiting_for_sessions_disconnect_ = false;

// Allows accessing Inspector from non-main threads

std::shared_ptr<MainThreadInterface> interface_;

std::shared_ptr<WorkerManager> worker_manager_;

if (start_io_thread_async_ == nullptr) return;

{

Mutex::ScopedLock lock(start_io_thread_agents_mutex);

std::erase(start_io_thread_agents, this);

}

parent_env_->RemoveCleanupHook(StopAcceptingIoThreadStartsHook, this);

parent_env_->CloseHandle(start_io_thread_async_,

[](uv_async_t* handle) { delete handle; });

start_io_thread_async_ = nullptr;

const DebugOptions& options,

std::shared_ptr<ExclusiveAccess<HostPort>> host_port,

bool is_main) {

path_ = path;

debug_options_ = options;

CHECK_NOT_NULL(host_port);

host_port_ = host_port;

client_ = std::make_shared<NodeInspectorClient>(parent_env_, is_main);

if (parent_env_->owns_inspector() &&

parent_env_->should_start_debug_signal_handler()) {

start_io_thread_async_ = new uv_async_t;

start_io_thread_async_->data = this;

CHECK_EQ(0,

uv_async_init(parent_env_->event_loop(),

start_io_thread_async_,

[](uv_async_t* handle) {

static_cast<Agent*>(handle->data)->StartIoThread();

}));

uv_unref(reinterpret_cast<uv_handle_t*>(start_io_thread_async_));

{

Mutex::ScopedLock lock(start_io_thread_agents_mutex);

start_io_thread_agents.push_back(this);

}

parent_env_->AddCleanupHook(StopAcceptingIoThreadStartsHook, this);

// Ignore failure, SIGUSR1 won't work, but that should not block node

// start.

StartDebugSignalHandler();

}

AtExit(parent_env_, [](void* env) {

Agent* agent = static_cast<Environment*>(env)->inspector_agent();

if (agent->IsActive()) {

agent->WaitForDisconnect();

}

}, parent_env_);

if (!parent_handle_ &&

(!options.inspector_enabled || !options.allow_attaching_debugger ||

!StartIoThread())) {

return false;

}

return true;

if (io_ != nullptr)

return true;

THROW_IF_INSUFFICIENT_PERMISSIONS(parent_env_,

permission::PermissionScope::kInspector,

"StartIoThread",

false);

if (!parent_env_->should_create_inspector() && !client_) {

ThrowUninitializedInspectorError(parent_env_);

return false;

}

CHECK_NOT_NULL(client_);

io_ = InspectorIo::Start(client_->getThreadHandle(),

path_,

host_port_,

debug_options_.inspect_publish_uid);

if (io_ == nullptr) {

return false;

}

NotifyClusterWorkersDebugEnabled(parent_env_);

return true;

std::unique_ptr<InspectorSessionDelegate> delegate,

bool prevent_shutdown) {

THROW_IF_INSUFFICIENT_PERMISSIONS(parent_env_,

permission::PermissionScope::kInspector,

"Connect",

std::unique_ptr<InspectorSession>{});

if (!parent_env_->should_create_inspector() && !client_) {

ThrowUninitializedInspectorError(parent_env_);

return std::unique_ptr<InspectorSession>{};

}

CHECK_NOT_NULL(client_);

int session_id = client_->connectFrontend(std::move(delegate),

prevent_shutdown);

return std::unique_ptr<InspectorSession>(

new SameThreadInspectorSession(session_id, client_));

std::unique_ptr<InspectorSessionDelegate> delegate,

bool prevent_shutdown) {

THROW_IF_INSUFFICIENT_PERMISSIONS(parent_env_,

permission::PermissionScope::kInspector,

"ConnectToMainThread",

std::unique_ptr<InspectorSession>{});

if (!parent_env_->should_create_inspector() && !client_) {

ThrowUninitializedInspectorError(parent_env_);

return std::unique_ptr<InspectorSession>{};

}

if (!parent_handle_) {

THROW_ERR_INSPECTOR_NOT_AVAILABLE(

parent_env_, "The parent thread's inspector is not available");

return std::unique_ptr<InspectorSession>{};

}

// A session connected to the main thread can pause it indefinitely.

if (ProcessTimeoutWatchdog::IsEnabled()) {

THROW_ERR_INSPECTOR_NOT_AVAILABLE(

parent_env_,

"Sessions cannot be connected to the main thread when "

"--process-timeout is used");

return std::unique_ptr<InspectorSession>{};

}

CHECK_NOT_NULL(client_);

auto thread_safe_delegate =

client_->getThreadHandle()->MakeDelegateThreadSafe(std::move(delegate));

return parent_handle_->Connect(std::move(thread_safe_delegate),

prevent_shutdown);

const StringView& event,

Local<Object> params) {

client_->emitNotification(context, event, params);

Local<Function> disable_function) {