Unified socket slots, --wire-debug CLI flag, fix mock TX and disconnect logging

Collapse 12 per-socket slots into 4 sender()-based slots. Replace runtime
wireDebug QML property with static --wire-debug CLI flag on both demo and
mock server. Route MockServer::sendKaPing through sendReply so KA_PING TX
shows wire bytes. Simplify sendReply to deduce command token from wire data.
Fix Xpl2Client disconnect logging (logTag takes pointer, null-sender fallback).

8 files changed, 209 insertions, 236 deletions

diff --git a/demo/CMakeLists.txt b/demo/CMakeLists.txt
index dd46473..bdee67f 100644
--- a/demo/CMakeLists.txt
+++ b/demo/CMakeLists.txt
@@ -17,3 +17,4 @@ set_target_properties(QtXpl2Demo PROPERTIES RUNTIME_OUTPUT_DIRECTORY
                                             "${PROJECT_BINARY_DIR}/bin")
 
 target_link_libraries(QtXpl2Demo PRIVATE Qt6::Quick QtXpl2plugin)
+target_include_directories(QtXpl2Demo PRIVATE "${PROJECT_SOURCE_DIR}/src")
diff --git a/demo/Main.qml b/demo/Main.qml
index edf317c..db015e3 100644
--- a/demo/Main.qml
+++ b/demo/Main.qml
@@ -23,23 +23,10 @@ ApplicationWindow {
             debugConsole.appendLog("ERROR: " + error);
         }
 
-        function onJcVersionReceived() {
-            debugConsole.appendLog(
-                        "JC Version: controller=%1 fw=%2 hw=%3 phCount=%4".arg(
-                            Xpl2Client.controllerId).arg(
-                            Xpl2Client.firmwareVersion).arg(
-                            Xpl2Client.hardwareVersion).arg(
-                            Xpl2Client.printheadCount));
-        }
-
         function onStatusMessage(message: string) {
             debugConsole.appendLog(message);
         }
 
-        function onWireDebugMessage(message: string) {
-            debugConsole.appendLog("WIRE: " + message);
-        }
-
         target: Xpl2Client
     }
 
@@ -84,13 +71,6 @@ ApplicationWindow {
                             Xpl2Client.connectToServer();
                         }
                     }
-
-                    CheckBox {
-                        checked: Xpl2Client.wireDebug
-                        text: "Wire debug"
-
-                        onToggled: Xpl2Client.wireDebug = checked
-                    }
                 }
             }
 
@@ -134,7 +114,8 @@ ApplicationWindow {
             id: debugConsole
 
             function appendLog(msg: string): void {
-                let ts = new Date().toLocaleTimeString(Qt.locale(), "HH:mm:ss");
+                let ts = new Date().toLocaleTimeString(Qt.locale(),
+                                                       "HH:mm:ss.zzz");
                 debugLog.text += "[" + ts + "] " + msg + "\n";
                 debugLog.cursorPosition = debugLog.text.length;
             }
diff --git a/demo/main.cpp b/demo/main.cpp
index 64c4f22..3100254 100644
--- a/demo/main.cpp
+++ b/demo/main.cpp
@@ -2,6 +2,9 @@
  * @file   main.cpp
  * @brief  Entry point for the QtXpl2 demo application.
  */
+#include "Xpl2Client.h"
+
+#include <QCommandLineParser>
 #include <QGuiApplication>
 #include <QQmlApplicationEngine>
 
@@ -11,8 +14,18 @@ Q_IMPORT_QML_PLUGIN (Xpl2Plugin)
 int
 main (int argc, char *argv[])
 {
+  qSetMessagePattern ("Demo       [%{time HH:mm:ss.zzz}] %{message}");
+
   QGuiApplication app (argc, argv);
 
+  QCommandLineParser parser;
+  parser.addOption ({ "wire-debug", "Log raw wire TX/RX to dev log" });
+  parser.addHelpOption ();
+  parser.process (app);
+
+  if (parser.isSet ("wire-debug"))
+    Xpl2Client::enableWireDebug ();
+
   QQmlApplicationEngine engine;
   QObject::connect (
       &engine, &QQmlApplicationEngine::objectCreationFailed, &app,
diff --git a/mock-server/MockServer.cpp b/mock-server/MockServer.cpp
index 52db5a1..d58e58e 100644
--- a/mock-server/MockServer.cpp
+++ b/mock-server/MockServer.cpp
@@ -6,6 +6,14 @@
 
 #include <QTcpSocket>
 
+bool MockServer::s_wireDebug = false;
+
+void
+MockServer::enableWireDebug ()
+{
+  s_wireDebug = true;
+}
+
 MockServer::MockServer (QObject *parent) : QObject (parent)
 {
   setupPort (m_command, "Command", 9110);
@@ -26,22 +34,26 @@ MockServer::setupPort (Port &port, const char *name, quint16 number)
            &MockServer::onNewConnection);
 
   if (!port.server.listen (QHostAddress::Any, number))
-    qCritical ("Failed to listen on %s port %d: %s", name, number,
+    qCritical ("%s Failed to listen: %s", qPrintable (logTag (number)),
                qPrintable (port.server.errorString ()));
   else
-    qInfo ("Listening on %s port %d", name, number);
+    qInfo ("%s Listening", qPrintable (logTag (number)));
 }
 
-const char *
-MockServer::portName (quint16 localPort) const
+QString
+MockServer::logTag (quint16 localPort) const
 {
+  const char *name = "Unknown";
   if (localPort == m_command.number)
-    return m_command.name;
-  if (localPort == m_imaging.number)
-    return m_imaging.name;
-  if (localPort == m_status.number)
-    return m_status.name;
-  return "Unknown";
+    name = m_command.name;
+  else if (localPort == m_imaging.number)
+    name = m_imaging.name;
+  else if (localPort == m_status.number)
+    name = m_status.name;
+
+  /* Fixed-width tag: "[Command:9110]" = 14 chars, left-padded to 15. */
+  return QStringLiteral ("[%1:%2]").arg (name).arg (localPort).leftJustified (
+      15);
 }
 
 void
@@ -51,7 +63,7 @@ MockServer::onNewConnection ()
   while (auto *sock = server->nextPendingConnection ())
     {
       quint16 lp = sock->localPort ();
-      qInfo ("[%s:%d] client connected", portName (lp), lp);
+      qInfo ("%s Client connected", qPrintable (logTag (lp)));
       m_clients.append (sock);
       connect (sock, &QTcpSocket::readyRead, this,
                &MockServer::onClientMessageReady);
@@ -76,7 +88,7 @@ MockServer::onClientDisconnected ()
 {
   auto *sock = qobject_cast<QTcpSocket *> (sender ());
   quint16 lp = sock->localPort ();
-  qInfo ("[%s:%d] client disconnected", portName (lp), lp);
+  qInfo ("%s Client disconnected", qPrintable (logTag (lp)));
   m_clients.removeOne (sock);
   sock->deleteLater ();
 }
@@ -87,7 +99,7 @@ MockServer::sendKaPing ()
   for (auto *client : m_clients)
     {
       if (client->state () == QAbstractSocket::ConnectedState)
-        client->write ("KA_PING\n");
+        sendReply (client, "KA_PING\n");
     }
 }
 
@@ -98,25 +110,47 @@ MockServer::handleCommand (QTcpSocket *client, const QByteArray &line)
   if (trimmed.isEmpty ())
     return;
 
-  quint16 lp = client->localPort ();
-
-  /* Split on first comma to get command token. */
+  /* Split on first comma to get command token and remaining params. */
   int comma = trimmed.indexOf (',');
   QByteArray cmd = (comma >= 0) ? trimmed.left (comma) : trimmed;
+  QByteArray params = (comma >= 0) ? trimmed.mid (comma + 1) : QByteArray ();
 
   if (cmd == "KA_PING")
-    {
-      qDebug ("[%s:%d] KA_PING ACK received", portName (lp), lp);
-      return;
-    }
+    handleKaPing (client, params);
+  else if (cmd == "GS_JC_VERSION")
+    handleGsJcVersion (client);
+  else
+    qWarning ("%s Unknown command: %s",
+              qPrintable (logTag (client->localPort ())), cmd.constData ());
+}
 
-  if (cmd == "GS_JC_VERSION")
-    {
-      qInfo ("[%s:%d] -> GS_JC_VERSION reply", portName (lp), lp);
-      client->write ("GS_JC_VERSION,1,\"1.05\",\"2.00\",15\n");
-      return;
-    }
+void
+MockServer::sendReply (QTcpSocket *client, const QByteArray &data)
+{
+  client->write (data);
+  QByteArray trimmed = data.trimmed ();
+  int comma = trimmed.indexOf (',');
+  QByteArray cmd = (comma >= 0) ? trimmed.left (comma) : trimmed;
+  QByteArray wire;
+  if (s_wireDebug)
+    wire = " >> " + trimmed;
+  qDebug ("%s TX %s%s", qPrintable (logTag (client->localPort ())),
+          cmd.constData (), wire.constData ());
+}
 
-  qWarning ("[%s:%d] Unknown command: %s", portName (lp), lp,
-            trimmed.constData ());
+void
+MockServer::handleKaPing (QTcpSocket *client, const QByteArray &params)
+{
+  QByteArray wire;
+  if (s_wireDebug)
+    wire = " << KA_PING," + params;
+  qDebug ("%s RX KA_PING ACK%s", qPrintable (logTag (client->localPort ())),
+          wire.constData ());
+}
+
+void
+MockServer::handleGsJcVersion (QTcpSocket *client)
+{
+  qDebug ("%s RX GS_JC_VERSION", qPrintable (logTag (client->localPort ())));
+  sendReply (client, "GS_JC_VERSION,1,\"1.05\",\"2.00\",15\n");
 }
diff --git a/mock-server/MockServer.h b/mock-server/MockServer.h
index 21d4d32..13bb2cd 100644
--- a/mock-server/MockServer.h
+++ b/mock-server/MockServer.h
@@ -17,11 +17,13 @@ class MockServer : public QObject
 
 public:
   explicit MockServer (QObject *parent = nullptr);
+  static void enableWireDebug ();
 
 private slots:
   void onNewConnection ();
   void onClientMessageReady ();
   void onClientDisconnected ();
+  /* Send KA_PING keepalive to all connected clients. */
   void sendKaPing ();
 
 private:
@@ -33,12 +35,18 @@ private:
   };
 
   void setupPort (Port &port, const char *name, quint16 number);
-  const char *portName (quint16 localPort) const;
+  /* Return a fixed-width "[Name:port]" tag for log lines. */
+  QString logTag (quint16 localPort) const;
+  /* Parse incoming line, log RX, and dispatch to the matching handler. */
   void handleCommand (QTcpSocket *client, const QByteArray &line);
+  void sendReply (QTcpSocket *client, const QByteArray &data);
+  void handleKaPing (QTcpSocket *client, const QByteArray &params);
+  void handleGsJcVersion (QTcpSocket *client);
 
   Port m_command;
   Port m_imaging;
   Port m_status;
   QList<QTcpSocket *> m_clients;
   QTimer m_pingTimer;
+  static bool s_wireDebug;
 };
diff --git a/mock-server/main.cpp b/mock-server/main.cpp
index b104685..5613462 100644
--- a/mock-server/main.cpp
+++ b/mock-server/main.cpp
@@ -4,13 +4,24 @@
  */
 #include "MockServer.h"
 
+#include <QCommandLineParser>
 #include <QCoreApplication>
 
 int
 main (int argc, char *argv[])
 {
+  qSetMessagePattern ("MockServer [%{time HH:mm:ss.zzz}] %{message}");
+
   QCoreApplication app (argc, argv);
 
+  QCommandLineParser parser;
+  parser.addOption ({ "wire-debug", "Log raw wire TX/RX to dev log" });
+  parser.addHelpOption ();
+  parser.process (app);
+
+  if (parser.isSet ("wire-debug"))
+    MockServer::enableWireDebug ();
+
   new MockServer (&app);
 
   return app.exec ();
diff --git a/src/Xpl2Client.cpp b/src/Xpl2Client.cpp
index f7b280f..ba6a1ec 100644
--- a/src/Xpl2Client.cpp
+++ b/src/Xpl2Client.cpp
@@ -6,34 +6,21 @@
 
 #include <QDebug>
 
+bool Xpl2Client::s_wireDebug = false;
+
 Xpl2Client::Xpl2Client (QObject *parent) : QObject (parent)
 {
-  connect (&m_commandSocket, &QTcpSocket::connected, this,
-           &Xpl2Client::onCommandSocketConnected);
-  connect (&m_commandSocket, &QTcpSocket::disconnected, this,
-           &Xpl2Client::onCommandSocketDisconnected);
-  connect (&m_commandSocket, &QTcpSocket::readyRead, this,
-           &Xpl2Client::onCommandSocketMessageReady);
-  connect (&m_commandSocket, &QAbstractSocket::errorOccurred, this,
-           &Xpl2Client::onCommandSocketError);
-
-  connect (&m_imagingSocket, &QTcpSocket::connected, this,
-           &Xpl2Client::onImagingSocketConnected);
-  connect (&m_imagingSocket, &QTcpSocket::disconnected, this,
-           &Xpl2Client::onImagingSocketDisconnected);
-  connect (&m_imagingSocket, &QTcpSocket::readyRead, this,
-           &Xpl2Client::onImagingSocketMessageReady);
-  connect (&m_imagingSocket, &QAbstractSocket::errorOccurred, this,
-           &Xpl2Client::onImagingSocketError);
-
-  connect (&m_statusSocket, &QTcpSocket::connected, this,
-           &Xpl2Client::onStatusSocketConnected);
-  connect (&m_statusSocket, &QTcpSocket::disconnected, this,
-           &Xpl2Client::onStatusSocketDisconnected);
-  connect (&m_statusSocket, &QTcpSocket::readyRead, this,
-           &Xpl2Client::onStatusSocketMessageReady);
-  connect (&m_statusSocket, &QAbstractSocket::errorOccurred, this,
-           &Xpl2Client::onStatusSocketError);
+  for (auto *socket : { &m_commandSocket, &m_imagingSocket, &m_statusSocket })
+    {
+      connect (socket, &QTcpSocket::connected, this,
+               &Xpl2Client::onSocketConnected);
+      connect (socket, &QTcpSocket::disconnected, this,
+               &Xpl2Client::onSocketDisconnected);
+      connect (socket, &QTcpSocket::readyRead, this,
+               &Xpl2Client::onSocketMessageReady);
+      connect (socket, &QAbstractSocket::errorOccurred, this,
+               &Xpl2Client::onSocketError);
+    }
 }
 
 /* ------------------------------------------------------------------ */
@@ -61,21 +48,6 @@ Xpl2Client::isConnected () const
   return m_connected;
 }
 
-bool
-Xpl2Client::wireDebug () const
-{
-  return m_wireDebug;
-}
-
-void
-Xpl2Client::setWireDebug (bool enabled)
-{
-  if (m_wireDebug == enabled)
-    return;
-  m_wireDebug = enabled;
-  emit wireDebugChanged ();
-}
-
 int
 Xpl2Client::controllerId () const
 {
@@ -100,6 +72,12 @@ Xpl2Client::printheadCount () const
   return m_printheadCount;
 }
 
+void
+Xpl2Client::enableWireDebug ()
+{
+  s_wireDebug = true;
+}
+
 /* ------------------------------------------------------------------ */
 /*  Connection                                                        */
 /* ------------------------------------------------------------------ */
@@ -142,59 +120,55 @@ Xpl2Client::sendCommand (QTcpSocket &socket, const QByteArray &command,
 {
   if (socket.state () != QAbstractSocket::ConnectedState)
     {
-      emit errorOccurred (QStringLiteral ("Socket not connected for %1")
+      emit errorOccurred (QStringLiteral ("Not connected for %1")
                               .arg (QString::fromUtf8 (command)));
       return;
     }
   QByteArray data = Xpl2Protocol::buildMessage (command, params);
   socket.write (data);
 
-  if (m_wireDebug)
-    emit wireDebugMessage (QStringLiteral ("TX [%1:%2] %3")
-                               .arg (socket.peerAddress ().toString ())
-                               .arg (socket.peerPort ())
-                               .arg (QString::fromUtf8 (data).trimmed ()));
+  QByteArray wire;
+  if (s_wireDebug)
+    wire = " >> " + data.trimmed ();
+  qDebug ("%s TX %s%s", qPrintable (logTag (&socket)), command.constData (),
+          wire.constData ());
 }
 
 void
 Xpl2Client::dispatchCommandMessage (const Xpl2Protocol::ParsedMessage &msg)
 {
   if (msg.command == "KA_PING")
-    {
-      handleKaPing (m_commandSocket);
-      return;
-    }
-  if (msg.command == "GS_JC_VERSION")
-    {
-      handleGsJcVersion (msg.params);
-      return;
-    }
+    handleKaPing (m_commandSocket);
+  else if (msg.command == "GS_JC_VERSION")
+    handleGsJcVersion (msg.params);
+  else
+    qWarning ("%s Unknown command: %s", qPrintable (logTag (&m_commandSocket)),
+              msg.command.constData ());
 }
 
 void
 Xpl2Client::dispatchImagingMessage (const Xpl2Protocol::ParsedMessage &msg)
 {
   if (msg.command == "KA_PING")
-    {
-      handleKaPing (m_imagingSocket);
-      return;
-    }
+    handleKaPing (m_imagingSocket);
+  else
+    qWarning ("%s Unknown command: %s", qPrintable (logTag (&m_imagingSocket)),
+              msg.command.constData ());
 }
 
 void
 Xpl2Client::dispatchStatusMessage (const Xpl2Protocol::ParsedMessage &msg)
 {
   if (msg.command == "KA_PING")
-    {
-      handleKaPing (m_statusSocket);
-      return;
-    }
+    handleKaPing (m_statusSocket);
+  else
+    qWarning ("%s Unknown command: %s", qPrintable (logTag (&m_statusSocket)),
+              msg.command.constData ());
 }
 
 void
 Xpl2Client::handleKaPing (QTcpSocket &socket)
 {
-  qDebug () << "KA_PING received, replying";
   sendCommand (socket, "KA_PING", { 1 });
 }
 
@@ -210,6 +184,16 @@ Xpl2Client::handleGsJcVersion (const QVariantList &params)
   m_firmwareVersion = params[1].toString ();
   m_hardwareVersion = params[2].toString ();
   m_printheadCount = params[3].toInt ();
+  qDebug ("%s    controller=%d fw=%s hw=%s phCount=%d",
+          qPrintable (logTag (&m_commandSocket)), m_controllerId,
+          qPrintable (m_firmwareVersion), qPrintable (m_hardwareVersion),
+          m_printheadCount);
+  emit statusMessage (
+      QStringLiteral ("RX JC Version: controller=%1 fw=%2 hw=%3 phCount=%4")
+          .arg (m_controllerId)
+          .arg (m_firmwareVersion)
+          .arg (m_hardwareVersion)
+          .arg (m_printheadCount));
   emit jcVersionReceived ();
 }
 
@@ -230,137 +214,90 @@ Xpl2Client::updateConnectedState ()
   emit connectedChanged ();
 }
 
-/* ------------------------------------------------------------------ */
-/*  Socket slots — command                                            */
-/* ------------------------------------------------------------------ */
-
-void
-Xpl2Client::onCommandSocketConnected ()
-{
-  emit statusMessage (QStringLiteral ("Command socket connected"));
-  updateConnectedState ();
-}
-
-void
-Xpl2Client::onCommandSocketDisconnected ()
-{
-  emit statusMessage (QStringLiteral ("Command socket disconnected"));
-  updateConnectedState ();
-}
-
-void
-Xpl2Client::onCommandSocketMessageReady ()
+QString
+Xpl2Client::logTag (const QTcpSocket *socket) const
 {
-  while (m_commandSocket.canReadLine ())
+  const char *name = "Unknown";
+  quint16 port = 0;
+  if (socket == &m_commandSocket)
     {
-      QByteArray raw = m_commandSocket.readLine ();
-      if (m_wireDebug)
-        emit wireDebugMessage (
-            QStringLiteral ("RX [%1:%2] %3")
-                .arg (m_commandSocket.peerAddress ().toString ())
-                .arg (m_commandSocket.peerPort ())
-                .arg (QString::fromUtf8 (raw).trimmed ()));
-
-      auto msg = Xpl2Protocol::parseMessage (raw);
-      if (msg.valid)
-        dispatchCommandMessage (msg);
+      name = "Command";
+      port = m_commandPort;
     }
-}
-
-void
-Xpl2Client::onCommandSocketError (QAbstractSocket::SocketError error)
-{
-  Q_UNUSED (error)
-  emit errorOccurred (
-      QStringLiteral ("Command: %1").arg (m_commandSocket.errorString ()));
-}
-
-/* ------------------------------------------------------------------ */
-/*  Socket slots — imaging                                            */
-/* ------------------------------------------------------------------ */
-
-void
-Xpl2Client::onImagingSocketConnected ()
-{
-  emit statusMessage (QStringLiteral ("Imaging socket connected"));
-  updateConnectedState ();
-}
-
-void
-Xpl2Client::onImagingSocketDisconnected ()
-{
-  emit statusMessage (QStringLiteral ("Imaging socket disconnected"));
-  updateConnectedState ();
-}
-
-void
-Xpl2Client::onImagingSocketMessageReady ()
-{
-  while (m_imagingSocket.canReadLine ())
+  else if (socket == &m_imagingSocket)
     {
-      QByteArray raw = m_imagingSocket.readLine ();
-      if (m_wireDebug)
-        emit wireDebugMessage (
-            QStringLiteral ("RX [%1:%2] %3")
-                .arg (m_imagingSocket.peerAddress ().toString ())
-                .arg (m_imagingSocket.peerPort ())
-                .arg (QString::fromUtf8 (raw).trimmed ()));
-
-      auto msg = Xpl2Protocol::parseMessage (raw);
-      if (msg.valid)
-        dispatchImagingMessage (msg);
+      name = "Imaging";
+      port = m_imagingPort;
+    }
+  else if (socket == &m_statusSocket)
+    {
+      name = "Status";
+      port = m_statusPort;
     }
-}
 
-void
-Xpl2Client::onImagingSocketError (QAbstractSocket::SocketError error)
-{
-  Q_UNUSED (error)
-  emit errorOccurred (
-      QStringLiteral ("Imaging: %1").arg (m_imagingSocket.errorString ()));
+  return QStringLiteral ("[%1:%2]").arg (name).arg (port).leftJustified (15);
 }
 
 /* ------------------------------------------------------------------ */
-/*  Socket slots — status                                             */
+/*  Socket slots                                                      */
 /* ------------------------------------------------------------------ */
 
 void
-Xpl2Client::onStatusSocketConnected ()
+Xpl2Client::onSocketConnected ()
 {
-  emit statusMessage (QStringLiteral ("Status socket connected"));
+  auto *socket = qobject_cast<QTcpSocket *> (sender ());
+  qInfo ("%s Connected", qPrintable (logTag (socket)));
   updateConnectedState ();
 }
 
 void
-Xpl2Client::onStatusSocketDisconnected ()
+Xpl2Client::onSocketDisconnected ()
 {
-  emit statusMessage (QStringLiteral ("Status socket disconnected"));
+  auto *socket = qobject_cast<QTcpSocket *> (sender ());
+  if (!socket)
+    {
+      /* Identify by elimination — which socket just left ConnectedState? */
+      for (auto *s : { &m_commandSocket, &m_imagingSocket, &m_statusSocket })
+        if (s->state () != QAbstractSocket::ConnectedState)
+          qInfo ("%s Disconnected", qPrintable (logTag (s)));
+    }
+  else
+    qInfo ("%s Disconnected", qPrintable (logTag (socket)));
   updateConnectedState ();
 }
 
 void
-Xpl2Client::onStatusSocketMessageReady ()
+Xpl2Client::onSocketMessageReady ()
 {
-  while (m_statusSocket.canReadLine ())
+  auto *socket = qobject_cast<QTcpSocket *> (sender ());
+  while (socket->canReadLine ())
     {
-      QByteArray raw = m_statusSocket.readLine ();
-      if (m_wireDebug)
-        emit wireDebugMessage (
-            QStringLiteral ("RX [%1:%2] %3")
-                .arg (m_statusSocket.peerAddress ().toString ())
-                .arg (m_statusSocket.peerPort ())
-                .arg (QString::fromUtf8 (raw).trimmed ()));
-
+      QByteArray raw = socket->readLine ();
       auto msg = Xpl2Protocol::parseMessage (raw);
       if (msg.valid)
-        dispatchStatusMessage (msg);
+        {
+          QByteArray wire;
+          if (s_wireDebug)
+            wire = " << " + raw.trimmed ();
+          qDebug ("%s RX %s%s", qPrintable (logTag (socket)),
+                  msg.command.constData (), wire.constData ());
+
+          if (socket == &m_commandSocket)
+            dispatchCommandMessage (msg);
+          else if (socket == &m_imagingSocket)
+            dispatchImagingMessage (msg);
+          else
+            dispatchStatusMessage (msg);
+        }
     }
 }
 
 void
-Xpl2Client::onStatusSocketError (QAbstractSocket::SocketError error)
+Xpl2Client::onSocketError (QAbstractSocket::SocketError error)
 {
   Q_UNUSED (error)
-  emit errorOccurred (
-      QStringLiteral ("Status: %1").arg (m_statusSocket.errorString ()));
+  auto *socket = qobject_cast<QTcpSocket *> (sender ());
+  emit errorOccurred (QStringLiteral ("%1 %2")
+                          .arg (logTag (socket))
+                          .arg (socket->errorString ()));
 }
diff --git a/src/Xpl2Client.h b/src/Xpl2Client.h
index 9212771..41729fd 100644
--- a/src/Xpl2Client.h
+++ b/src/Xpl2Client.h
@@ -18,8 +18,6 @@ class Xpl2Client : public QObject
 
   Q_PROPERTY (QString host READ host WRITE setHost NOTIFY hostChanged)
   Q_PROPERTY (bool connected READ isConnected NOTIFY connectedChanged)
-  Q_PROPERTY (
-      bool wireDebug READ wireDebug WRITE setWireDebug NOTIFY wireDebugChanged)
   Q_PROPERTY (int controllerId READ controllerId NOTIFY jcVersionReceived)
   Q_PROPERTY (
       QString firmwareVersion READ firmwareVersion NOTIFY jcVersionReceived)
@@ -35,14 +33,13 @@ public:
 
   bool isConnected () const;
 
-  bool wireDebug () const;
-  void setWireDebug (bool enabled);
-
   int controllerId () const;
   QString firmwareVersion () const;
   QString hardwareVersion () const;
   int printheadCount () const;
 
+  static void enableWireDebug ();
+
   Q_INVOKABLE void connectToServer ();
   Q_INVOKABLE void disconnectFromServer ();
   Q_INVOKABLE void getJcVersion ();
@@ -50,25 +47,15 @@ public:
 signals:
   void hostChanged ();
   void connectedChanged ();
-  void wireDebugChanged ();
   void errorOccurred (const QString &error);
   void statusMessage (const QString &message);
-  void wireDebugMessage (const QString &message);
   void jcVersionReceived ();
 
 private slots:
-  void onCommandSocketConnected ();
-  void onCommandSocketDisconnected ();
-  void onCommandSocketMessageReady ();
-  void onCommandSocketError (QAbstractSocket::SocketError error);
-  void onImagingSocketConnected ();
-  void onImagingSocketDisconnected ();
-  void onImagingSocketMessageReady ();
-  void onImagingSocketError (QAbstractSocket::SocketError error);
-  void onStatusSocketConnected ();
-  void onStatusSocketDisconnected ();
-  void onStatusSocketMessageReady ();
-  void onStatusSocketError (QAbstractSocket::SocketError error);
+  void onSocketConnected ();
+  void onSocketDisconnected ();
+  void onSocketMessageReady ();
+  void onSocketError (QAbstractSocket::SocketError error);
 
 private:
   void sendCommand (QTcpSocket &socket, const QByteArray &command,
@@ -79,6 +66,7 @@ private:
   void handleKaPing (QTcpSocket &socket);
   void handleGsJcVersion (const QVariantList &params);
   void updateConnectedState ();
+  QString logTag (const QTcpSocket *socket) const;
 
   QTcpSocket m_commandSocket;
   QTcpSocket m_imagingSocket;
@@ -88,7 +76,7 @@ private:
   quint16 m_imagingPort = 9111;
   quint16 m_statusPort = 9112;
   bool m_connected = false;
-  bool m_wireDebug = false;
+  static bool s_wireDebug;
   int m_controllerId = 0;
   QString m_firmwareVersion;
   QString m_hardwareVersion;