fix(startup): lazy-start search/imagehost worker threads to avoid pre-QApplication QEventLoop warning

SearchService and ImageHostService started their worker QThread in their constructors, which run before the QApplication is created in main(). The default QThread::run() calls exec(), constructing a QEventLoop while QCoreApplication::instance() is still null, emitting "QEventLoop: Cannot be used without QCoreApplication".

Defer moveToThread + start() to a lazy ensureWorkerThreadStarted() invoked on first async use (always after the app is running). Parent the worker to the service so a session that never searches/uploads still reclaims it via QObject child deletion; unparent before moveToThread on first start so the existing finished->deleteLater cleanup owns it thereafter.

Author: tamlok

src/core/services/imagehostservice.cpp

@@ -25,8 +25,13 @@ ImageHostService::ImageHostService(HookManager *p_hookMgr, QObject *p_parent)
   qRegisterMetaType<ImageHostAsyncResult>();
 
   m_thread = new QThread(this);
-  m_worker = new ImageHostWorker();
-  m_worker->moveToThread(m_thread);
+  // Parent the worker to this service. If no async op runs this session the
+  // worker QThread never starts, so the finished->deleteLater below never
+  // fires; QObject child deletion then reclaims the worker. On the first async
+  // op, ensureWorkerThreadStarted() unparents it and moves it onto m_thread
+  // (deferred out of this constructor because it runs before QApplication
+  // exists), after which finished->deleteLater owns it.
+  m_worker = new ImageHostWorker(nullptr, this);
 
   connect(m_thread, &QThread::finished, m_worker, &QObject::deleteLater);
 
@@ -45,6 +50,22 @@ ImageHostService::ImageHostService(HookManager *p_hookMgr, QObject *p_parent)
             emit uploadFinished(p_token, result);
           });
 
+  // NOTE: m_thread is started lazily on the first async op (see
+  // ensureWorkerThreadStarted()), NOT here. This constructor runs in main()
+  // BEFORE the QApplication is created, so starting the QThread now would run
+  // QThread::exec() -> QEventLoop while QCoreApplication::instance() is still
+  // null, emitting "QEventLoop: Cannot be used without QCoreApplication".
+}
+
+void ImageHostService::ensureWorkerThreadStarted() {
+  // Idempotent and GUI-thread-only, so no lock is needed. Unparent before
+  // moveToThread (Qt forbids moving a parented object across threads); after
+  // this the finished->deleteLater connection owns the worker.
+  if (m_thread->isRunning()) {
+    return;
+  }
+  m_worker->setParent(nullptr);
+  m_worker->moveToThread(m_thread);
   m_thread->start();
 }
 
@@ -263,6 +284,7 @@ int ImageHostService::uploadAsync(IImageHostProvider *p_provider, const QByteArr
   item.path = p_path;
   item.providerName = p_provider->getName();
 
+  ensureWorkerThreadStarted();
   QMetaObject::invokeMethod(m_worker, "doUpload", Qt::QueuedConnection,
                             Q_ARG(ImageHostWorkItem, item));
   return item.token;
@@ -292,6 +314,7 @@ int ImageHostService::removeAsync(IImageHostProvider *p_provider, const QString
   item.path = p_url;
   item.providerName = p_provider->getName();
 
+  ensureWorkerThreadStarted();
   QMetaObject::invokeMethod(m_worker, "doRemove", Qt::QueuedConnection,
                             Q_ARG(ImageHostWorkItem, item));
   return item.token;
@@ -304,6 +327,7 @@ int ImageHostService::testConfigAsync(const QString &p_typeId, const QJsonObject
   item.typeId = p_typeId;
   item.config = p_config;
 
+  ensureWorkerThreadStarted();
   QMetaObject::invokeMethod(m_worker, "doTestConfig", Qt::QueuedConnection,
                             Q_ARG(ImageHostWorkItem, item));
   return item.token;

src/core/services/imagehostservice.h

@@ -119,6 +119,14 @@ private slots:
   void onRemoveCompleted(int p_token, const ImageHostAsyncResult &p_result);
 
 private:
+  // Lazily start the worker QThread on the first async operation. Deferred out
+  // of the constructor because ImageHostService is constructed in main() BEFORE
+  // the QApplication exists; starting the QThread there would run
+  // QThread::exec() -> QEventLoop with no QCoreApplication, emitting
+  // "QEventLoop: Cannot be used without QCoreApplication". Called on the GUI
+  // thread from the *Async entry points only, so it needs no locking.
+  void ensureWorkerThreadStarted();
+
   HookManager *m_hookMgr = nullptr;
 
   QVector<IImageHostProvider *> m_providers;

src/core/services/searchservice.cpp

@@ -287,8 +287,13 @@ SearchService::SearchService(SearchCoreService *p_coreService, QObject *p_parent
   qRegisterMetaType<Error>();
   qRegisterMetaType<std::atomic<int> *>("std::atomic<int>*");
 
-  m_worker = new SearchWorker(m_coreService, m_mutex);
-  m_worker->moveToThread(m_thread);
+  // Parent the worker to this service. If no search runs this session the
+  // worker QThread never starts, so the finished->deleteLater below never
+  // fires; QObject child deletion then reclaims the worker. On the first
+  // search, ensureWorkerThreadStarted() unparents it and moves it onto
+  // m_thread (deferred out of this constructor because it runs before
+  // QApplication exists), after which finished->deleteLater owns it.
+  m_worker = new SearchWorker(m_coreService, m_mutex, this);
 
   connect(m_thread, &QThread::finished, m_worker, &QObject::deleteLater);
 
@@ -317,8 +322,12 @@ SearchService::SearchService(SearchCoreService *p_coreService, QObject *p_parent
     emit searchCancelled(p_token);
   });
 
-  m_thread->start();
-
+  // NOTE: m_thread is started lazily on the first search (see
+  // ensureWorkerThreadStarted()), NOT here. This constructor runs in main()
+  // BEFORE the QApplication is created, so starting the QThread now would run
+  // QThread::exec() -> QEventLoop while QCoreApplication::instance() is still
+  // null, emitting "QEventLoop: Cannot be used without QCoreApplication". The
+  // std::thread drain pool below runs no event loop, so it stays here.
   unsigned n = std::thread::hardware_concurrency();
   if (n == 0) {
     n = 2;
@@ -353,6 +362,18 @@ SearchService::~SearchService() {
   m_mutex = nullptr;
 }
 
+void SearchService::ensureWorkerThreadStarted() {
+  // Idempotent and GUI-thread-only, so no lock is needed. Unparent before
+  // moveToThread (Qt forbids moving a parented object across threads); after
+  // this the finished->deleteLater connection owns the worker.
+  if (m_thread->isRunning()) {
+    return;
+  }
+  m_worker->setParent(nullptr);
+  m_worker->moveToThread(m_thread);
+  m_thread->start();
+}
+
 int SearchService::searchFiles(const QString &p_notebookId, const QString &p_queryJson,
                                const QString &p_inputFilesJson) {
   qDebug() << "SearchService::searchFiles: notebookId:" << p_notebookId;
@@ -363,6 +384,7 @@ int SearchService::searchFiles(const QString &p_notebookId, const QString &p_que
   m_activeTokens.insert(token);
   emit searchStarted(token);
 
+  ensureWorkerThreadStarted();
   const bool invoked = QMetaObject::invokeMethod(
       m_worker, "doSearchFiles", Qt::QueuedConnection, Q_ARG(int, token),
       Q_ARG(QString, p_notebookId), Q_ARG(QString, p_queryJson), Q_ARG(QString, p_inputFilesJson),
@@ -386,6 +408,7 @@ int SearchService::searchContent(const QString &p_notebookId, const QString &p_q
   m_activeTokens.insert(token);
   emit searchStarted(token);
 
+  ensureWorkerThreadStarted();
   const bool invoked = QMetaObject::invokeMethod(
       m_worker, "doSearchContent", Qt::QueuedConnection, Q_ARG(int, token),
       Q_ARG(QString, p_notebookId), Q_ARG(QString, p_queryJson), Q_ARG(QString, p_inputFilesJson),
@@ -409,6 +432,7 @@ int SearchService::searchByTags(const QString &p_notebookId, const QString &p_qu
   m_activeTokens.insert(token);
   emit searchStarted(token);
 
+  ensureWorkerThreadStarted();
   const bool invoked = QMetaObject::invokeMethod(
       m_worker, "doSearchByTags", Qt::QueuedConnection, Q_ARG(int, token),
       Q_ARG(QString, p_notebookId), Q_ARG(QString, p_queryJson), Q_ARG(QString, p_inputFilesJson),

src/core/services/searchservice.h

@@ -65,6 +65,14 @@ class SearchService : public QObject {
   void searchBatch(int p_token, const SearchResult &p_result);
 
 private:
+  // Lazily start the worker QThread on first search. Deferred out of the
+  // constructor because SearchService is constructed in main() BEFORE the
+  // QApplication exists; starting the QThread there would run QThread::exec()
+  // -> QEventLoop with no QCoreApplication, emitting
+  // "QEventLoop: Cannot be used without QCoreApplication". Called on the GUI
+  // thread from the search entry points only, so it needs no locking.
+  void ensureWorkerThreadStarted();
+
   SearchCoreService *m_coreService = nullptr;
   SearchWorker *m_worker = nullptr;
   QThread *m_thread = nullptr;