Address cloud upload review feedback for safety and robustness.

fernandotonon · cursoragent · fernandotonon · commit 208c36d01ca7 · 2026-06-21T02:09:37.000-04:00
Use shared cancel flags so worker threads outlive session teardown, guard
GUI uploads against overlapping project lists and stale tokens, tighten MCP
dependency selection with a timeout, and add a test watchdog against hangs.

Co-authored-by: Cursor &lt;cursoragent@cursor.com&gt;
diff --git a/src/MCPServer.cpp b/src/MCPServer.cpp
@@ -5277,9 +5277,17 @@ QJsonObject MCPServer::toolCloudUpload(const QJsonObject &args)
 
     const bool runScan = !args.contains(QStringLiteral("scan")) || args.value(QStringLiteral("scan")).toBool(true);
 
+    const QString mainCanonical = QFileInfo(filePath).canonicalFilePath();
     QStringList selectedPaths;
-    for (const DependencyEntry& entry : DependencyResolver::detect(filePath))
-        selectedPaths.append(entry.absolutePath);
+    selectedPaths.append(mainCanonical);
+    for (const DependencyEntry& entry : DependencyResolver::detect(filePath)) {
+        if (!entry.exists || !entry.checkedByDefault)
+            continue;
+        const QString absolute = QFileInfo(entry.absolutePath).absoluteFilePath();
+        if (absolute == mainCanonical)
+            continue;
+        selectedPaths.append(absolute);
+    }
 
     CloudPackageUploadRequest request;
     request.mainAssetPath = filePath;
@@ -5294,7 +5302,7 @@ QJsonObject MCPServer::toolCloudUpload(const QJsonObject &args)
     QString error;
     QString reportWarning;
     bool uploadOk = false;
-    int uploadedFileCount = selectedPaths.size();
+    const int uploadedFileCount = selectedPaths.size();
     connect(&session, &QtMeshCloudSession::uploadFinished, &loop,
             [&](bool ok, const QString& err, const QString& url, const QString&) {
                 uploadOk = ok;
@@ -5310,6 +5318,16 @@ QJsonObject MCPServer::toolCloudUpload(const QJsonObject &args)
         error = QStringLiteral("Upload canceled");
         loop.quit();
     });
+    QTimer timeout;
+    timeout.setSingleShot(true);
+    timeout.setInterval(10 * 60 * 1000);
+    connect(&timeout, &QTimer::timeout, &loop, [&]() {
+        session.cancel();
+        uploadOk = false;
+        error = QStringLiteral("Upload timed out");
+        loop.quit();
+    });
+    timeout.start();
     session.uploadPackageFromAssets(request);
     loop.exec();
 
diff --git a/src/QtMeshCloudSession.cpp b/src/QtMeshCloudSession.cpp
@@ -80,6 +80,8 @@ QtMeshCloudSession::QtMeshCloudSession(const QString& bearerToken, QObject* pare
 void QtMeshCloudSession::cancel()
 {
     m_canceled.store(true);
+    if (m_uploadCancelFlag)
+        m_uploadCancelFlag->store(true);
 }
 
 void QtMeshCloudSession::listProjects()
@@ -107,18 +109,21 @@ void QtMeshCloudSession::uploadPackage(const PackageMetadata& metadata,
                                        const QString& projectSlug,
                                        bool createNewProject)
 {
+    m_uploadCancelFlag = std::make_shared<std::atomic_bool>(false);
     m_canceled.store(false);
     startUploadWorker(metadata, ownerSlug, projectSlug, createNewProject);
 }
 
 void QtMeshCloudSession::uploadPackageFromAssets(const CloudPackageUploadRequest& request)
 {
+    m_uploadCancelFlag = std::make_shared<std::atomic_bool>(false);
     m_canceled.store(false);
     const QString token = m_bearerToken;
     const CloudPackageUploadRequest req = request;
     QPointer<QtMeshCloudSession> self(this);
+    const std::shared_ptr<std::atomic_bool> canceled = m_uploadCancelFlag;
 
-    QThread* worker = QThread::create([self, token, req, canceled = &m_canceled]() {
+    QThread* worker = QThread::create([self, token, req, canceled]() {
         if (canceled->load()) {
             invokeUploadCanceled(self);
             return;
@@ -247,7 +252,7 @@ void QtMeshCloudSession::uploadPackageFromAssets(const CloudPackageUploadRequest
             invokeUploadProgress(self, i + 1, total + 1, descriptors.at(i).uploadName);
 
             const auto result = QtMeshCloudClient::uploadFileContent(
-                token, uploadUrls.uploads.at(i), descriptors.at(i).path, canceled);
+                token, uploadUrls.uploads.at(i), descriptors.at(i).path, canceled.get());
             if (result.canceled) {
                 invokeUploadCanceled(self);
                 return;
@@ -288,13 +293,13 @@ void QtMeshCloudSession::uploadPackageFromAssets(const CloudPackageUploadRequest
                 reportWarning = QStringLiteral("File uploaded, but analysis report upload failed.");
                 if (!reportResult.errorString.isEmpty())
                     reportWarning += QStringLiteral("\n\n") + reportResult.errorString;
-                SentryReporter::addBreadcrumb(QStringLiteral("cloud.upload"),
+                SentryReporter::addBreadcrumb(QStringLiteral("file.export"),
                                               reportWarning,
                                               QStringLiteral("warning"));
             }
         }
 
-        SentryReporter::addBreadcrumb(QStringLiteral("cloud.upload"),
+        SentryReporter::addBreadcrumb(QStringLiteral("file.export"),
                                       QStringLiteral("QtMesh Cloud package upload completed"));
         invokeUploadFinished(self, true, reportWarning, project.projectUrl, completed.scanStatus);
     });
@@ -310,9 +315,10 @@ void QtMeshCloudSession::startUploadWorker(const PackageMetadata& package,
 {
     const QString token = m_bearerToken;
     QPointer<QtMeshCloudSession> self(this);
+    const std::shared_ptr<std::atomic_bool> canceled = m_uploadCancelFlag;
 
     QThread* worker = QThread::create([self, token, package, ownerSlug, projectSlug, createNewProject,
-                                       canceled = &m_canceled]() {
+                                       canceled]() {
         if (canceled->load()) {
             invokeUploadCanceled(self);
             return;
@@ -380,7 +386,7 @@ void QtMeshCloudSession::startUploadWorker(const PackageMetadata& package,
             invokeUploadProgress(self, i + 1, total + 1, descriptors.at(i).uploadName);
 
             const auto result = QtMeshCloudClient::uploadFileContent(
-                token, uploadUrls.uploads.at(i), descriptors.at(i).path, canceled);
+                token, uploadUrls.uploads.at(i), descriptors.at(i).path, canceled.get());
             if (result.canceled) {
                 invokeUploadCanceled(self);
                 return;
@@ -421,13 +427,13 @@ void QtMeshCloudSession::startUploadWorker(const PackageMetadata& package,
                 reportWarning = QStringLiteral("File uploaded, but analysis report upload failed.");
                 if (!reportResult.errorString.isEmpty())
                     reportWarning += QStringLiteral("\n\n") + reportResult.errorString;
-                SentryReporter::addBreadcrumb(QStringLiteral("cloud.upload"),
+                SentryReporter::addBreadcrumb(QStringLiteral("file.export"),
                                               reportWarning,
                                               QStringLiteral("warning"));
             }
         }
 
-        SentryReporter::addBreadcrumb(QStringLiteral("cloud.upload"),
+        SentryReporter::addBreadcrumb(QStringLiteral("file.export"),
                                       QStringLiteral("QtMesh Cloud package upload completed"));
         invokeUploadFinished(self, true, reportWarning, project.projectUrl, completed.scanStatus);
     });
diff --git a/src/QtMeshCloudSession.h b/src/QtMeshCloudSession.h
@@ -6,6 +6,7 @@
 
 #include <QObject>
 #include <atomic>
+#include <memory>
 
 struct CloudPackageUploadRequest {
     QString mainAssetPath;
@@ -60,6 +61,7 @@ class QtMeshCloudSession : public QObject {
 
     QString m_bearerToken;
     std::atomic_bool m_canceled{false};
+    std::shared_ptr<std::atomic_bool> m_uploadCancelFlag;
 };
 
 #endif // QTMESH_CLOUD_SESSION_H
diff --git a/src/QtMeshCloudSession_test.cpp b/src/QtMeshCloudSession_test.cpp
@@ -15,6 +15,7 @@
 #include <QTcpServer>
 #include <QTcpSocket>
 #include <QTemporaryDir>
+#include <QTimer>
 #include <memory>
 
 namespace {
@@ -210,9 +211,14 @@ TEST_F(QtMeshCloudSessionUploadReportTest, ReportFailureDoesNotFailBinaryUpload)
             });
 
     session.uploadPackage(manifest);
+    QTimer watchdog;
+    watchdog.setSingleShot(true);
+    watchdog.setInterval(30000);
+    QObject::connect(&watchdog, &QTimer::timeout, &loop, &QEventLoop::quit);
+    watchdog.start();
     loop.exec();
 
-    EXPECT_TRUE(uploadOk);
+    ASSERT_TRUE(uploadOk) << "uploadFinished never fired (timeout or failure)";
     EXPECT_TRUE(m_mock->completeCalled());
     EXPECT_TRUE(m_mock->reportCalled());
     EXPECT_TRUE(uploadError.contains(QStringLiteral("analysis report upload failed"),
diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
@@ -2747,17 +2747,25 @@ void MainWindow::uploadFilesToQtMeshCloud()
         return;
     }
 
+    if (m_cloudUploadListingInFlight) {
+        statusBar()->showMessage(tr("Cloud upload already in progress…"), 3000);
+        return;
+    }
+    m_cloudUploadListingInFlight = true;
+
     statusBar()->showMessage(tr("Loading cloud projects…"), 0);
     m_cloudUploadProgress->start(tr("Loading cloud projects…"), 1);
 
     QtMeshCloudSession* session = cloudSessionForToken(token);
+    disconnect(session, &QtMeshCloudSession::projectsListed, this, nullptr);
     QPointer<MainWindow> self(this);
     connect(session, &QtMeshCloudSession::projectsListed, this,
             [self, token, mainAssetPath](const QList<QtMeshCloudClient::ProjectSummary>& projects,
                                          const QString& listError) {
                 if (!self)
                     return;
 
+                self->m_cloudUploadListingInFlight = false;
                 self->m_cloudUploadProgress->hideProgress();
                 self->statusBar()->clearMessage();
 
@@ -2775,6 +2783,21 @@ void MainWindow::uploadFilesToQtMeshCloud()
                     return;
                 }
 
+                if (!CloudCredentialStore::hasSession()) {
+                    QMessageBox::warning(self, self->tr("QtMesh Cloud Upload"),
+                                         self->tr("Your QtMesh Cloud session expired. Sign in again."));
+                    self->updateCloudAuthActions();
+                    return;
+                }
+                const QString currentToken = CloudCredentialStore::loadSession().token;
+                if (currentToken.isEmpty() || currentToken != token) {
+                    QMessageBox::warning(self, self->tr("QtMesh Cloud Upload"),
+                                         self->tr("Your QtMesh Cloud session changed while loading "
+                                                  "projects. Sign in again and retry."));
+                    self->updateCloudAuthActions();
+                    return;
+                }
+
                 CloudUploadDialog dialog(self);
                 dialog.setAccountLabel(storedCloudDisplayName());
                 dialog.setProjects(projects);
@@ -2800,7 +2823,7 @@ void MainWindow::uploadFilesToQtMeshCloud()
                 request.createNewProject = false;
                 request.runLocalScan = dialog.runLocalScanBeforeUpload();
 
-                self->startCloudPackageUpload(self->cloudSessionForToken(token), request);
+                self->startCloudPackageUpload(self->cloudSessionForToken(currentToken), request);
             },
             Qt::SingleShotConnection);
 
diff --git a/src/mainwindow.h b/src/mainwindow.h
@@ -206,6 +206,7 @@ public slots:
     CloudUploadProgress* m_cloudUploadProgress = nullptr;
     QtMeshCloudSession* m_cloudSession = nullptr;
     QAction* m_cloudUploadMenuAction = nullptr;
+    bool m_cloudUploadListingInFlight = false;
 
     void updateCloudUploadActionState();
     void startCloudPackageUpload(QtMeshCloudSession* session,
