LibDevTools: Introduce a Firefox DevTools server library

To aid with debugging web page issues in Ladybird without needing to
implement a fully fledged inspector, we can implement the Firefox
DevTools protocol and use their DevTools. The protocol is described
here:

https://firefox-source-docs.mozilla.org/devtools/backend/protocol.html

This commit contains just enough to connect to Ladybird from a DevTools
client.

AK/Debug.h.in

@@ -50,6 +50,10 @@
 #    cmakedefine01 CSS_TRANSITIONS_DEBUG
 #endif
 
+#ifndef DEVTOOLS_DEBUG
+#    cmakedefine01 DEVTOOLS_DEBUG
+#endif
+
 #ifndef DNS_DEBUG
 #    cmakedefine01 DNS_DEBUG
 #endif

Libraries/LibDevTools/Actor.cpp

@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2025, Tim Flynn <trflynn89@ladybird.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <AK/JsonObject.h>
+#include <LibDevTools/Actor.h>
+#include <LibDevTools/Connection.h>
+#include <LibDevTools/DevToolsServer.h>
+
+namespace DevTools {
+
+Actor::Actor(DevToolsServer& devtools, ByteString name)
+    : m_devtools(devtools)
+    , m_name(move(name))
+{
+}
+
+Actor::~Actor() = default;
+
+void Actor::send_message(JsonValue message, Optional<BlockToken> block_token)
+{
+    if (m_block_responses && !block_token.has_value()) {
+        m_blocked_responses.append(move(message));
+        return;
+    }
+
+    if (auto& connection = devtools().connection())
+        connection->send_message(message);
+}
+
+// https://firefox-source-docs.mozilla.org/devtools/backend/protocol.html#error-packets
+void Actor::send_missing_parameter_error(StringView parameter)
+{
+    JsonObject error;
+    error.set("from"sv, name());
+    error.set("error"sv, "missingParameter"sv);
+    error.set("message"sv, ByteString::formatted("Missing parameter: '{}'", parameter));
+    send_message(move(error));
+}
+
+// https://firefox-source-docs.mozilla.org/devtools/backend/protocol.html#error-packets
+void Actor::send_unrecognized_packet_type_error(StringView type)
+{
+    JsonObject error;
+    error.set("from"sv, name());
+    error.set("error"sv, "unrecognizedPacketType"sv);
+    error.set("message"sv, ByteString::formatted("Unrecognized packet type: '{}'", type));
+    send_message(move(error));
+}
+
+// https://github.com/mozilla/gecko-dev/blob/master/devtools/server/actors/object.js
+// This error is not documented, but is used by Firefox nonetheless.
+void Actor::send_unknown_actor_error(StringView actor)
+{
+    JsonObject error;
+    error.set("from"sv, name());
+    error.set("error"sv, "unknownActor"sv);
+    error.set("message"sv, ByteString::formatted("Unknown actor: '{}'", actor));
+    send_message(move(error));
+}
+
+Actor::BlockToken Actor::block_responses()
+{
+    // https://firefox-source-docs.mozilla.org/devtools/backend/protocol.html#the-request-reply-pattern
+    // The actor processes packets in the order they are received, and the client can trust that the i’th reply
+    // corresponds to the i’th request.
+
+    // The above requirement gets tricky for actors which require an async implementation. For example, the "getWalker"
+    // message sent to the InspectorActor results in the server fetching the DOM tree as JSON from the WebContent process.
+    // We cannot reply to the message until that is received. However, we will likely receive more messages from the
+    // client in that time. We cannot reply to those messages until we've replied to the "getWalker" message. Thus, we
+    // use this token to queue responses from the actor until that reply can be sent.
+    return { {}, *this };
+}
+
+Actor::BlockToken::BlockToken(Badge<Actor>, Actor& actor)
+    : m_actor(actor)
+{
+    // If we end up in a situtation where an actor has multiple async handlers at once, we will need to come up with a
+    // more sophisticated blocking mechanism.
+    VERIFY(!actor.m_block_responses);
+    actor.m_block_responses = true;
+}
+
+Actor::BlockToken::BlockToken(BlockToken&& other)
+    : m_actor(move(other.m_actor))
+{
+}
+
+Actor::BlockToken& Actor::BlockToken::operator=(BlockToken&& other)
+{
+    m_actor = move(other.m_actor);
+    return *this;
+}
+
+Actor::BlockToken::~BlockToken()
+{
+    auto actor = m_actor.strong_ref();
+    if (!actor)
+        return;
+
+    auto blocked_responses = move(actor->m_blocked_responses);
+    actor->m_block_responses = false;
+
+    for (auto& message : blocked_responses)
+        actor->send_message(move(message));
+}
+
+}

Libraries/LibDevTools/Actor.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2025, Tim Flynn <trflynn89@ladybird.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <AK/Badge.h>
+#include <AK/ByteString.h>
+#include <AK/Optional.h>
+#include <AK/RefCounted.h>
+#include <AK/StringView.h>
+#include <AK/Vector.h>
+#include <AK/WeakPtr.h>
+#include <AK/Weakable.h>
+#include <LibDevTools/Forward.h>
+
+namespace DevTools {
+
+class Actor
+    : public RefCounted<Actor>
+    , public Weakable<Actor> {
+public:
+    virtual ~Actor();
+
+    ByteString const& name() const { return m_name; }
+    virtual void handle_message(StringView type, JsonObject const&) = 0;
+
+    class [[nodiscard]] BlockToken {
+    public:
+        BlockToken(Badge<Actor>, Actor&);
+        ~BlockToken();
+
+        BlockToken(BlockToken const&) = delete;
+        BlockToken& operator=(BlockToken const&) = delete;
+
+        BlockToken(BlockToken&&);
+        BlockToken& operator=(BlockToken&&);
+
+    private:
+        WeakPtr<Actor> m_actor;
+    };
+
+    void send_message(JsonValue, Optional<BlockToken> block_token = {});
+    void send_missing_parameter_error(StringView parameter);
+    void send_unrecognized_packet_type_error(StringView type);
+    void send_unknown_actor_error(StringView actor);
+
+protected:
+    explicit Actor(DevToolsServer&, ByteString name);
+
+    DevToolsServer& devtools() { return m_devtools; }
+    DevToolsServer const& devtools() const { return m_devtools; }
+
+    BlockToken block_responses();
+
+private:
+    DevToolsServer& m_devtools;
+    ByteString m_name;
+
+    Vector<JsonValue> m_blocked_responses;
+    bool m_block_responses { false };
+};
+
+}

Libraries/LibDevTools/Actors/DeviceActor.cpp

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2025, Tim Flynn <trflynn89@ladybird.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <AK/JsonObject.h>
+#include <AK/String.h>
+#include <LibCore/Version.h>
+#include <LibDevTools/Actors/DeviceActor.h>
+#include <LibWeb/Loader/UserAgent.h>
+
+namespace DevTools {
+
+NonnullRefPtr<DeviceActor> DeviceActor::create(DevToolsServer& devtools, ByteString name)
+{
+    return adopt_ref(*new DeviceActor(devtools, move(name)));
+}
+
+DeviceActor::DeviceActor(DevToolsServer& devtools, ByteString name)
+    : Actor(devtools, move(name))
+{
+}
+
+DeviceActor::~DeviceActor() = default;
+
+void DeviceActor::handle_message(StringView type, JsonObject const&)
+{
+    if (type == "getDescription"sv) {
+        auto build_id = Core::Version::read_long_version_string().to_byte_string();
+
+        // https://github.com/mozilla/gecko-dev/blob/master/devtools/shared/system.js
+        JsonObject value;
+        value.set("apptype"sv, "ladybird"sv);
+        value.set("name"sv, BROWSER_NAME);
+        value.set("brandName"sv, BROWSER_NAME);
+        value.set("version"sv, BROWSER_VERSION);
+        value.set("appbuildid"sv, build_id);
+        value.set("platformbuildid"sv, build_id);
+        value.set("platformversion"sv, "135.0"sv);
+        value.set("useragent"sv, Web::default_user_agent);
+        value.set("os"sv, OS_STRING);
+        value.set("arch"sv, CPU_STRING);
+
+        JsonObject response;
+        response.set("from"sv, name());
+        response.set("value"sv, move(value));
+
+        send_message(move(response));
+        return;
+    }
+
+    send_unrecognized_packet_type_error(type);
+}
+
+}

Libraries/LibDevTools/Actors/DeviceActor.h

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2025, Tim Flynn <trflynn89@ladybird.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <AK/NonnullRefPtr.h>
+#include <LibDevTools/Actor.h>
+
+namespace DevTools {
+
+class DeviceActor final : public Actor {
+public:
+    static constexpr auto base_name = "device"sv;
+
+    static NonnullRefPtr<DeviceActor> create(DevToolsServer&, ByteString name);
+    virtual ~DeviceActor() override;
+
+    virtual void handle_message(StringView type, JsonObject const&) override;
+
+private:
+    DeviceActor(DevToolsServer&, ByteString name);
+};
+
+}

Libraries/LibDevTools/Actors/PreferenceActor.cpp

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2025, Tim Flynn <trflynn89@ladybird.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <AK/JsonObject.h>
+#include <LibDevTools/Actors/PreferenceActor.h>
+
+namespace DevTools {
+
+NonnullRefPtr<PreferenceActor> PreferenceActor::create(DevToolsServer& devtools, ByteString name)
+{
+    return adopt_ref(*new PreferenceActor(devtools, move(name)));
+}
+
+PreferenceActor::PreferenceActor(DevToolsServer& devtools, ByteString name)
+    : Actor(devtools, move(name))
+{
+}
+
+PreferenceActor::~PreferenceActor() = default;
+
+void PreferenceActor::handle_message(StringView type, JsonObject const&)
+{
+    // FIXME: During session initialization, Firefox DevTools asks for the following boolean configurations:
+    //            browser.privatebrowsing.autostart
+    //            devtools.debugger.prompt-connection
+    //            dom.serviceWorkers.enabled
+    //        We just blindly return `false` for these, but we will eventually want a real configuration manager.
+    if (type == "getBoolPref"sv) {
+        JsonObject response;
+        response.set("from"sv, name());
+        response.set("value"sv, false);
+        send_message(move(response));
+        return;
+    }
+
+    send_unrecognized_packet_type_error(type);
+}
+
+}

Libraries/LibDevTools/Actors/PreferenceActor.h

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2025, Tim Flynn <trflynn89@ladybird.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <AK/NonnullRefPtr.h>
+#include <LibDevTools/Actor.h>
+
+namespace DevTools {
+
+class PreferenceActor final : public Actor {
+public:
+    static constexpr auto base_name = "preference"sv;
+
+    static NonnullRefPtr<PreferenceActor> create(DevToolsServer&, ByteString name);
+    virtual ~PreferenceActor() override;
+
+    virtual void handle_message(StringView type, JsonObject const&) override;
+
+private:
+    PreferenceActor(DevToolsServer&, ByteString name);
+};
+
+}

Libraries/LibDevTools/Actors/ProcessActor.cpp

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2025, Tim Flynn <trflynn89@ladybird.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <AK/JsonObject.h>
+#include <LibDevTools/Actors/ProcessActor.h>
+
+namespace DevTools {
+
+NonnullRefPtr<ProcessActor> ProcessActor::create(DevToolsServer& devtools, ByteString name, ProcessDescription description)
+{
+    return adopt_ref(*new ProcessActor(devtools, move(name), move(description)));
+}
+
+ProcessActor::ProcessActor(DevToolsServer& devtools, ByteString name, ProcessDescription description)
+    : Actor(devtools, move(name))
+    , m_description(move(description))
+{
+}
+
+ProcessActor::~ProcessActor() = default;
+
+void ProcessActor::handle_message(StringView type, JsonObject const&)
+{
+    send_unrecognized_packet_type_error(type);
+}
+
+JsonObject ProcessActor::serialize_description() const
+{
+    JsonObject traits;
+    traits.set("watcher"sv, m_description.is_parent);
+    traits.set("supportsReloadDescriptor"sv, true);
+
+    JsonObject description;
+    description.set("actor"sv, name());
+    description.set("id"sv, m_description.id);
+    description.set("isParent"sv, m_description.is_parent);
+    description.set("isWindowlessParent"sv, m_description.is_windowless_parent);
+    description.set("traits"sv, move(traits));
+    return description;
+}
+
+}

Libraries/LibDevTools/Actors/ProcessActor.h

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2025, Tim Flynn <trflynn89@ladybird.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <AK/NonnullRefPtr.h>
+#include <LibDevTools/Actor.h>
+
+namespace DevTools {
+
+struct ProcessDescription {
+    u64 id { 0 };
+    bool is_parent { false };
+    bool is_windowless_parent { false };
+};
+
+class ProcessActor final : public Actor {
+public:
+    static constexpr auto base_name = "process"sv;
+
+    static NonnullRefPtr<ProcessActor> create(DevToolsServer&, ByteString name, ProcessDescription);
+    virtual ~ProcessActor() override;
+
+    virtual void handle_message(StringView type, JsonObject const&) override;
+
+    ProcessDescription const& description() const { return m_description; }
+    JsonObject serialize_description() const;
+
+private:
+    ProcessActor(DevToolsServer&, ByteString name, ProcessDescription);
+
+    ProcessDescription m_description;
+};
+
+}

Libraries/LibDevTools/Actors/RootActor.cpp

@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) 2025, Tim Flynn <trflynn89@ladybird.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <AK/JsonObject.h>
+#include <LibDevTools/Actors/DeviceActor.h>
+#include <LibDevTools/Actors/PreferenceActor.h>
+#include <LibDevTools/Actors/ProcessActor.h>
+#include <LibDevTools/Actors/RootActor.h>
+#include <LibDevTools/DevToolsDelegate.h>
+#include <LibDevTools/DevToolsServer.h>
+
+namespace DevTools {
+
+// https://firefox-source-docs.mozilla.org/devtools/backend/protocol.html#the-root-actor
+NonnullRefPtr<RootActor> RootActor::create(DevToolsServer& devtools, ByteString name)
+{
+    auto actor = adopt_ref(*new RootActor(devtools, move(name)));
+
+    JsonObject traits;
+    traits.set("sources"sv, false);
+    traits.set("highlightable"sv, true);
+    traits.set("customHighlighters"sv, true);
+    traits.set("networkMonitor"sv, false);
+
+    JsonObject message;
+    message.set("from"sv, actor->name());
+    message.set("applicationType"sv, "browser"sv);
+    message.set("traits"sv, move(traits));
+    actor->send_message(move(message));
+
+    return actor;
+}
+
+RootActor::RootActor(DevToolsServer& devtools, ByteString name)
+    : Actor(devtools, move(name))
+{
+}
+
+RootActor::~RootActor() = default;
+
+void RootActor::handle_message(StringView type, JsonObject const& message)
+{
+    JsonObject response;
+    response.set("from"sv, name());
+
+    if (type == "connect") {
+        send_message(move(response));
+        return;
+    }
+
+    if (type == "getRoot"sv) {
+        response.set("selected"sv, 0);
+
+        for (auto const& actor : devtools().actor_registry()) {
+            if (is<DeviceActor>(*actor.value))
+                response.set("deviceActor"sv, actor.key);
+            else if (is<PreferenceActor>(*actor.value))
+                response.set("preferenceActor"sv, actor.key);
+        }
+
+        send_message(move(response));
+        return;
+    }
+
+    if (type == "getProcess"sv) {
+        auto id = message.get_integer<u64>("id"sv);
+        if (!id.has_value()) {
+            send_missing_parameter_error("id"sv);
+            return;
+        }
+
+        for (auto const& actor : devtools().actor_registry()) {
+            auto const* process_actor = as_if<ProcessActor>(*actor.value);
+            if (!process_actor)
+                continue;
+            if (process_actor->description().id != *id)
+                continue;
+
+            response.set("processDescriptor"sv, process_actor->serialize_description());
+            break;
+        }
+
+        send_message(move(response));
+        return;
+    }
+
+    if (type == "getTab"sv) {
+        response.set("tab"sv, JsonObject {});
+        send_message(move(response));
+        return;
+    }
+
+    if (type == "listAddons"sv) {
+        response.set("addons"sv, JsonArray {});
+        send_message(move(response));
+        return;
+    }
+
+    if (type == "listProcesses"sv) {
+        JsonArray processes;
+
+        for (auto const& actor : devtools().actor_registry()) {
+            if (auto const* process_actor = as_if<ProcessActor>(*actor.value))
+                processes.must_append(process_actor->serialize_description());
+        }
+
+        response.set("processes"sv, move(processes));
+        send_message(move(response));
+        return;
+    }
+
+    if (type == "listServiceWorkerRegistrations"sv) {
+        response.set("registrations"sv, JsonArray {});
+        send_message(move(response));
+        return;
+    }
+
+    if (type == "listTabs"sv) {
+        response.set("tabs"sv, JsonArray {});
+        send_message(move(response));
+        return;
+    }
+
+    if (type == "listWorkers"sv) {
+        response.set("workers"sv, JsonArray {});
+        send_message(move(response));
+        return;
+    }
+
+    send_unrecognized_packet_type_error(type);
+}
+
+}

Libraries/LibDevTools/Actors/RootActor.h

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2025, Tim Flynn <trflynn89@ladybird.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <AK/NonnullRefPtr.h>
+#include <LibDevTools/Actor.h>
+
+namespace DevTools {
+
+class RootActor final : public Actor {
+public:
+    static constexpr auto base_name = "root"sv;
+
+    static NonnullRefPtr<RootActor> create(DevToolsServer&, ByteString name);
+    virtual ~RootActor() override;
+
+    virtual void handle_message(StringView type, JsonObject const&) override;
+
+private:
+    RootActor(DevToolsServer&, ByteString name);
+};
+
+}

Libraries/LibDevTools/CMakeLists.txt

@@ -0,0 +1,12 @@
+set(SOURCES
+    Actor.cpp
+    Actors/DeviceActor.cpp
+    Actors/PreferenceActor.cpp
+    Actors/ProcessActor.cpp
+    Actors/RootActor.cpp
+    Connection.cpp
+    DevToolsServer.cpp
+)
+
+serenity_lib(LibDevTools devtools)
+target_link_libraries(LibDevTools PRIVATE LibCore LibWeb)

Libraries/LibDevTools/Connection.cpp

@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2025, Tim Flynn <trflynn89@ladybird.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <AK/Debug.h>
+#include <AK/JsonObject.h>
+#include <AK/JsonValue.h>
+#include <AK/StringBuilder.h>
+#include <LibCore/EventLoop.h>
+#include <LibDevTools/Connection.h>
+
+namespace DevTools {
+
+NonnullRefPtr<Connection> Connection::create(NonnullOwnPtr<Core::BufferedTCPSocket> socket)
+{
+    return adopt_ref(*new Connection(move(socket)));
+}
+
+Connection::Connection(NonnullOwnPtr<Core::BufferedTCPSocket> socket)
+    : m_socket(move(socket))
+{
+    m_socket->on_ready_to_read = [this]() {
+        if (auto result = on_ready_to_read(); result.is_error()) {
+            if (on_connection_closed)
+                on_connection_closed();
+        }
+    };
+}
+
+Connection::~Connection() = default;
+
+// https://firefox-source-docs.mozilla.org/devtools/backend/protocol.html#packets
+void Connection::send_message(JsonValue const& message)
+{
+    auto serialized = message.serialized<StringBuilder>();
+
+    if constexpr (DEVTOOLS_DEBUG) {
+        if (message.is_object() && message.as_object().get("error"sv).has_value())
+            dbgln("\x1b[1;31m<<\x1b[0m {}", serialized);
+        else
+            dbgln("\x1b[1;32m<<\x1b[0m {}", serialized);
+    }
+
+    if (m_socket->write_formatted("{}:{}", serialized.length(), serialized).is_error()) {
+        if (on_connection_closed)
+            on_connection_closed();
+    }
+}
+
+// https://firefox-source-docs.mozilla.org/devtools/backend/protocol.html#packets
+ErrorOr<JsonValue> Connection::read_message()
+{
+    ByteBuffer length_buffer;
+
+    // FIXME: `read_until(':')` would be nicer here, but that seems to return immediately without receiving any data.
+    while (true) {
+        auto byte = TRY(m_socket->read_value<u8>());
+        if (byte == ':') {
+            break;
+        }
+
+        length_buffer.append(byte);
+    }
+
+    auto length = StringView { length_buffer }.to_number<size_t>();
+    if (!length.has_value())
+        return Error::from_string_literal("Could not read message length from DevTools client");
+
+    ByteBuffer message_buffer;
+    message_buffer.resize(*length);
+
+    TRY(m_socket->read_until_filled(message_buffer));
+
+    auto message = TRY(JsonValue::from_string(message_buffer));
+    dbgln_if(DEVTOOLS_DEBUG, "\x1b[1;33m>>\x1b[0m {}", message);
+
+    return message;
+}
+
+ErrorOr<void> Connection::on_ready_to_read()
+{
+    // https://firefox-source-docs.mozilla.org/devtools/backend/protocol.html#the-request-reply-pattern
+    // Note that it is correct for a client to send several requests to a request/reply actor without waiting for a
+    // reply to each request before sending the next; requests can be pipelined.
+    while (TRY(m_socket->can_read_without_blocking())) {
+        auto message = TRY(read_message());
+        if (!message.is_object())
+            continue;
+
+        Core::deferred_invoke([this, message = move(message)]() {
+            if (on_message_received)
+                on_message_received(message.as_object());
+        });
+    }
+
+    return {};
+}
+
+}

Libraries/LibDevTools/Connection.h

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2025, Tim Flynn <trflynn89@ladybird.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <AK/Error.h>
+#include <AK/Function.h>
+#include <AK/NonnullOwnPtr.h>
+#include <AK/NonnullRefPtr.h>
+#include <AK/RefCounted.h>
+#include <LibCore/Socket.h>
+#include <LibDevTools/Forward.h>
+
+namespace DevTools {
+
+class Connection : public RefCounted<Connection> {
+public:
+    static NonnullRefPtr<Connection> create(NonnullOwnPtr<Core::BufferedTCPSocket>);
+    ~Connection();
+
+    Function<void()> on_connection_closed;
+    Function<void(JsonObject const&)> on_message_received;
+
+    void send_message(JsonValue const&);
+
+private:
+    explicit Connection(NonnullOwnPtr<Core::BufferedTCPSocket>);
+
+    ErrorOr<void> on_ready_to_read();
+    ErrorOr<JsonValue> read_message();
+
+    NonnullOwnPtr<Core::BufferedTCPSocket> m_socket;
+};
+
+}

Libraries/LibDevTools/DevToolsDelegate.h

@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2025, Tim Flynn <trflynn89@ladybird.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <LibDevTools/Forward.h>
+
+namespace DevTools {
+
+class DevToolsDelegate {
+public:
+    virtual ~DevToolsDelegate() = default;
+};
+
+}

Libraries/LibDevTools/DevToolsServer.cpp

@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2025, Tim Flynn <trflynn89@ladybird.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <AK/Debug.h>
+#include <AK/JsonObject.h>
+#include <AK/JsonValue.h>
+#include <LibCore/EventLoop.h>
+#include <LibCore/Socket.h>
+#include <LibCore/TCPServer.h>
+#include <LibDevTools/Actors/DeviceActor.h>
+#include <LibDevTools/Actors/PreferenceActor.h>
+#include <LibDevTools/Actors/ProcessActor.h>
+#include <LibDevTools/Connection.h>
+#include <LibDevTools/DevToolsServer.h>
+
+namespace DevTools {
+
+static u64 s_server_count = 0;
+
+ErrorOr<NonnullOwnPtr<DevToolsServer>> DevToolsServer::create(DevToolsDelegate& delegate, u16 port)
+{
+    auto address = IPv4Address::from_string("0.0.0.0"sv).release_value();
+
+    auto server = TRY(Core::TCPServer::try_create());
+    TRY(server->listen(address, port, Core::TCPServer::AllowAddressReuse::Yes));
+
+    return adopt_own(*new DevToolsServer(delegate, move(server)));
+}
+
+DevToolsServer::DevToolsServer(DevToolsDelegate& delegate, NonnullRefPtr<Core::TCPServer> server)
+    : m_server(move(server))
+    , m_delegate(delegate)
+    , m_server_id(s_server_count++)
+{
+    m_server->on_ready_to_accept = [this]() {
+        if (auto result = on_new_client(); result.is_error())
+            warnln("Failed to accept DevTools client: {}", result.error());
+    };
+}
+
+DevToolsServer::~DevToolsServer() = default;
+
+ErrorOr<void> DevToolsServer::on_new_client()
+{
+    if (m_connection)
+        return Error::from_string_literal("Only one active DevTools connection is currently allowed");
+
+    auto client = TRY(m_server->accept());
+    auto buffered_socket = TRY(Core::BufferedTCPSocket::create(move(client)));
+
+    m_connection = Connection::create(move(buffered_socket));
+
+    m_connection->on_connection_closed = [this]() {
+        close_connection();
+    };
+
+    m_connection->on_message_received = [this](auto const& message) {
+        on_message_received(message);
+    };
+
+    m_root_actor = register_actor<RootActor>();
+
+    register_actor<DeviceActor>();
+    register_actor<PreferenceActor>();
+    register_actor<ProcessActor>(ProcessDescription { .is_parent = true });
+
+    return {};
+}
+
+void DevToolsServer::on_message_received(JsonObject const& message)
+{
+    auto to = message.get_byte_string("to"sv);
+    if (!to.has_value()) {
+        m_root_actor->send_missing_parameter_error("to"sv);
+        return;
+    }
+
+    auto actor = m_actor_registry.find(*to);
+    if (actor == m_actor_registry.end()) {
+        m_root_actor->send_unknown_actor_error(*to);
+        return;
+    }
+
+    auto type = message.get_byte_string("type"sv);
+    if (!type.has_value()) {
+        actor->value->send_missing_parameter_error("type"sv);
+        return;
+    }
+
+    actor->value->handle_message(*type, message);
+}
+
+void DevToolsServer::close_connection()
+{
+    dbgln_if(DEVTOOLS_DEBUG, "Lost connection to the DevTools client");
+
+    Core::deferred_invoke([this]() {
+        m_connection = nullptr;
+        m_actor_registry.clear();
+        m_root_actor = nullptr;
+    });
+}
+
+}

Libraries/LibDevTools/DevToolsServer.h

@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2025, Tim Flynn <trflynn89@ladybird.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <AK/Error.h>
+#include <AK/HashMap.h>
+#include <AK/NonnullOwnPtr.h>
+#include <AK/NonnullRefPtr.h>
+#include <LibCore/Socket.h>
+#include <LibDevTools/Actors/RootActor.h>
+#include <LibDevTools/Forward.h>
+
+namespace DevTools {
+
+using ActorRegistry = HashMap<ByteString, NonnullRefPtr<Actor>>;
+
+class DevToolsServer {
+public:
+    static ErrorOr<NonnullOwnPtr<DevToolsServer>> create(DevToolsDelegate&, u16 port);
+    ~DevToolsServer();
+
+    RefPtr<Connection>& connection() { return m_connection; }
+    DevToolsDelegate const& delegate() const { return m_delegate; }
+    ActorRegistry const& actor_registry() const { return m_actor_registry; }
+
+    template<typename ActorType, typename... Args>
+    ActorType& register_actor(Args&&... args)
+    {
+        ByteString name;
+
+        if constexpr (IsSame<ActorType, RootActor>) {
+            name = ActorType::base_name;
+        } else {
+            name = ByteString::formatted("server{}-{}{}", m_server_id, ActorType::base_name, m_actor_count);
+        }
+
+        auto actor = ActorType::create(*this, name, forward<Args>(args)...);
+        m_actor_registry.set(name, actor);
+        ++m_actor_count;
+
+        return actor;
+    }
+
+private:
+    explicit DevToolsServer(DevToolsDelegate&, NonnullRefPtr<Core::TCPServer>);
+
+    ErrorOr<void> on_new_client();
+    void on_message_received(JsonObject const&);
+
+    void close_connection();
+
+    NonnullRefPtr<Core::TCPServer> m_server;
+    RefPtr<Connection> m_connection;
+
+    DevToolsDelegate& m_delegate;
+
+    ActorRegistry m_actor_registry;
+    RefPtr<RootActor> m_root_actor { nullptr };
+
+    u64 m_server_id { 0 };
+    u64 m_actor_count { 0 };
+};
+
+}

Libraries/LibDevTools/Forward.h

@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2025, Tim Flynn <trflynn89@ladybird.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+namespace DevTools {
+
+class Actor;
+class Connection;
+class DeviceActor;
+class DevToolsDelegate;
+class DevToolsServer;
+class PreferenceActor;
+class ProcessActor;
+class RootActor;
+
+struct ProcessDescription;
+
+}

Meta/CMake/all_the_debug_macros.cmake

@@ -8,6 +8,7 @@ set(CSS_LOADER_DEBUG ON)
 set(CSS_PARSER_DEBUG ON)
 set(CSS_TOKENIZER_DEBUG ON)
 set(CSS_TRANSITIONS_DEBUG ON)
+set(DEVTOOLS_DEBUG ON)
 set(DNS_DEBUG ON)
 set(EDITOR_DEBUG ON)
 set(EMOJI_DEBUG ON)

Meta/Lagom/CMakeLists.txt

@@ -413,6 +413,7 @@ set(lagom_standard_libraries
 
 if (ENABLE_GUI_TARGETS)
     list(APPEND lagom_standard_libraries
+        DevTools
         Gfx
         ImageDecoderClient
         Media