Upload QtMesh Cloud scan reports after file complete and keep GUI responsive.

Add uploadFileReport() and call it after completeUpload in the CLI, session, and MCP paths so analysis shows on the website. Move scan, manifest prep, and project listing off the main thread to prevent the app from freezing during upload.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: fernandotonon

src/CLIPipeline.cpp

@@ -777,6 +777,7 @@ void CLIPipeline::printUsage()
         "  cloud list [--json]               List cloud projects for the signed-in account.\n"
         "  cloud upload <file> [--name <n>] [--no-scan] [--json]\n"
         "                                    Package the asset + dependencies and upload to QtMesh Cloud.\n"
+        "                                    After files/complete, uploads the local scan report to the main file.\n"
         "  cloud delete <project-id>         Delete a cloud project by id.\n"
         "\n"
         "Global options:\n"

src/CloudCLIPipeline.cpp

@@ -346,6 +346,21 @@ int cmdCloudUpload(int argc, char* argv[])
         return 1;
     }
 
+    QString reportWarning;
+    if (!manifest.scanSummary.isEmpty() && !mainFileId.isEmpty()) {
+        const auto reportResult = QtMeshCloudClient::uploadFileReport(
+            token, project.ownerSlug, project.projectSlug, mainFileId, manifest.scanSummary);
+        if (!reportResult.ok) {
+            reportWarning = QStringLiteral("File uploaded, but analysis report upload failed.");
+            SentryReporter::addBreadcrumb(QStringLiteral("file.export"),
+                                          QStringLiteral("QtMesh Cloud CLI report upload failed"),
+                                          QStringLiteral("warning"));
+            err() << "Warning: " << reportWarning << Qt::endl;
+            if (!reportResult.errorString.isEmpty())
+                err() << reportResult.errorString << Qt::endl;
+        }
+    }
+
     const QString projectUrl = project.projectUrl;
     SentryReporter::addBreadcrumb(QStringLiteral("file.export"),
                                   QStringLiteral("QtMesh Cloud CLI upload completed"));
@@ -355,6 +370,8 @@ int cmdCloudUpload(int argc, char* argv[])
         obj.insert(QStringLiteral("ok"), true);
         obj.insert(QStringLiteral("projectUrl"), projectUrl);
         obj.insert(QStringLiteral("fileCount"), manifest.files.size());
+        if (!reportWarning.isEmpty())
+            obj.insert(QStringLiteral("reportWarning"), reportWarning);
         out() << QString::fromUtf8(QJsonDocument(obj).toJson(QJsonDocument::Compact)) << Qt::endl;
     } else {
         out() << "Uploaded " << manifest.files.size() << " file(s).";

src/CloudUploadDialog.cpp

@@ -166,22 +166,19 @@ bool CloudUploadDialog::runLocalScanBeforeUpload() const
     return m_runScanCheck->isChecked();
 }
 
-QStringList CloudUploadDialog::selectedAbsolutePaths() const
+QStringList CloudUploadDialog::selectedAbsolutePathsForUpload() const
 {
-    QStringList extras;
-    for (int row = 0; row < m_dependencyList->count(); ++row) {
-        QListWidgetItem* item = m_dependencyList->item(row);
-        if (item && item->checkState() == Qt::Checked)
-            extras.append(item->data(Qt::UserRole).toString());
-    }
-    return extras;
+    return selectedAbsolutePaths();
 }
 
-PackageMetadata CloudUploadDialog::manifest() const
+PackageMetadata CloudUploadDialog::buildManifestForUpload(const QString& mainAssetPath,
+                                                          const QStringList& selectedAbsolutePaths,
+                                                          const QString& projectName,
+                                                          const QJsonObject& scanSummary)
 {
-    const QString mainCanonical = QFileInfo(m_mainAssetPath).absoluteFilePath();
+    const QString mainCanonical = QFileInfo(mainAssetPath).absoluteFilePath();
     QSet<QString> selected;
-    for (const QString& path : selectedAbsolutePaths())
+    for (const QString& path : selectedAbsolutePaths)
         selected.insert(QFileInfo(path).absoluteFilePath());
 
     QStringList extras;
@@ -190,7 +187,7 @@ PackageMetadata CloudUploadDialog::manifest() const
             extras.append(path);
     }
     PackageMetadata metadata =
-        ProjectPackager::buildManifest(m_mainAssetPath, extras, projectName());
+        ProjectPackager::buildManifest(mainAssetPath, extras, projectName);
     metadata.files.erase(
         std::remove_if(metadata.files.begin(), metadata.files.end(),
                        [&](const PackageEntry& entry) {
@@ -200,7 +197,24 @@ PackageMetadata CloudUploadDialog::manifest() const
     metadata.totalSize = 0;
     for (const PackageEntry& entry : metadata.files)
         metadata.totalSize += entry.size;
-    if (!m_scanSummary.isEmpty())
-        metadata.scanSummary = m_scanSummary;
+    if (!scanSummary.isEmpty())
+        metadata.scanSummary = scanSummary;
     return metadata;
 }
+
+QStringList CloudUploadDialog::selectedAbsolutePaths() const
+{
+    QStringList extras;
+    for (int row = 0; row < m_dependencyList->count(); ++row) {
+        QListWidgetItem* item = m_dependencyList->item(row);
+        if (item && item->checkState() == Qt::Checked)
+            extras.append(item->data(Qt::UserRole).toString());
+    }
+    return extras;
+}
+
+PackageMetadata CloudUploadDialog::manifest() const
+{
+    return buildManifestForUpload(m_mainAssetPath, selectedAbsolutePaths(), projectName(),
+                                m_scanSummary);
+}

src/CloudUploadDialog.h

@@ -27,9 +27,15 @@ class CloudUploadDialog : public QDialog {
     bool hasSelectedProject() const;
     QtMeshCloudClient::ProjectSummary selectedProject() const;
     QString projectName() const;
+    QStringList selectedAbsolutePathsForUpload() const;
     PackageMetadata manifest() const;
     bool runLocalScanBeforeUpload() const;
 
+    static PackageMetadata buildManifestForUpload(const QString& mainAssetPath,
+                                                  const QStringList& selectedAbsolutePaths,
+                                                  const QString& projectName,
+                                                  const QJsonObject& scanSummary = QJsonObject());
+
 private:
     void rebuildDependencyList();
     QStringList selectedAbsolutePaths() const;

src/CloudUploadProgress.cpp

@@ -43,7 +43,12 @@ void CloudUploadProgress::updateProgress(int current, int total, const QString&
 {
     m_bar->setMaximum(qMax(1, total));
     m_bar->setValue(current);
-    m_label->setText(tr("Uploading %1…").arg(fileName));
+    if (fileName.isEmpty())
+        return;
+    if (fileName.endsWith(QChar(0x2026)) || fileName.endsWith(QLatin1Char('.')))
+        m_label->setText(fileName);
+    else
+        m_label->setText(tr("Uploading %1…").arg(fileName));
 }
 
 void CloudUploadProgress::finish(bool ok, const QString& message)

src/MCPServer.cpp

@@ -29,6 +29,7 @@
 #include "UvUnwrap.h"
 #include "AssetScanController.h"
 #include "CloudCredentialStore.h"
+#include "DependencyResolver.h"
 #include "ProjectPackager.h"
 #include "QtMeshCloudClient.h"
 #include "QtMeshCloudSession.h"
@@ -5274,46 +5275,53 @@ QJsonObject MCPServer::toolCloudUpload(const QJsonObject &args)
     if (projectName.isEmpty())
         projectName = QFileInfo(filePath).completeBaseName();
 
-    PackageMetadata manifest = ProjectPackager::buildManifest(filePath, {}, projectName);
     const bool runScan = !args.contains(QStringLiteral("scan")) || args.value(QStringLiteral("scan")).toBool(true);
-    if (runScan) {
-        QString scanError;
-        const QByteArray scanJson = AssetScanController::runIsolatedScanJsonSync(
-            QFileInfo(filePath).absolutePath(), QFileInfo(filePath).fileName(), &scanError);
-        if (!scanJson.isEmpty()) {
-            QJsonParseError parseError;
-            const QJsonDocument doc = QJsonDocument::fromJson(scanJson, &parseError);
-            if (parseError.error == QJsonParseError::NoError && doc.isObject())
-                manifest.scanSummary = doc.object();
-        }
-    }
+
+    QStringList selectedPaths;
+    for (const DependencyEntry& entry : DependencyResolver::detect(filePath))
+        selectedPaths.append(entry.absolutePath);
+
+    CloudPackageUploadRequest request;
+    request.mainAssetPath = filePath;
+    request.selectedAbsolutePaths = selectedPaths;
+    request.projectName = projectName;
+    request.createNewProject = true;
+    request.runLocalScan = runScan;
 
     QtMeshCloudSession session(token);
     QEventLoop loop;
     QString projectUrl;
     QString error;
+    QString reportWarning;
+    bool uploadOk = false;
+    int uploadedFileCount = selectedPaths.size();
     connect(&session, &QtMeshCloudSession::uploadFinished, &loop,
             [&](bool ok, const QString& err, const QString& url, const QString&) {
+                uploadOk = ok;
                 projectUrl = url;
-                error = err;
-                if (!ok && error.isEmpty())
-                    error = QStringLiteral("Upload failed");
+                if (ok && !err.isEmpty())
+                    reportWarning = err;
+                else if (!ok)
+                    error = err.isEmpty() ? QStringLiteral("Upload failed") : err;
                 loop.quit();
             });
     connect(&session, &QtMeshCloudSession::uploadCanceled, &loop, [&]() {
+        uploadOk = false;
         error = QStringLiteral("Upload canceled");
         loop.quit();
     });
-    session.uploadPackage(manifest);
+    session.uploadPackageFromAssets(request);
     loop.exec();
 
-    if (!error.isEmpty())
+    if (!uploadOk)
         return makeErrorResult(error);
 
     QJsonObject content;
     content[QStringLiteral("ok")] = true;
     content[QStringLiteral("projectUrl")] = projectUrl;
-    content[QStringLiteral("fileCount")] = manifest.files.size();
+    content[QStringLiteral("fileCount")] = uploadedFileCount;
+    if (!reportWarning.isEmpty())
+        content[QStringLiteral("reportWarning")] = reportWarning;
     return makeSuccessResult(
         QString::fromUtf8(QJsonDocument(content).toJson(QJsonDocument::Indented)));
 }

src/QtMeshCloudClient.cpp

@@ -1056,6 +1056,93 @@ QtMeshCloudClient::CompleteUploadResult QtMeshCloudClient::completeUpload(
     return out;
 }
 
+QtMeshCloudClient::UploadResult QtMeshCloudClient::uploadFileReport(
+    const QString& bearerToken,
+    const QString& ownerSlug,
+    const QString& projectSlug,
+    const QString& fileId,
+    const QJsonObject& report,
+    int timeoutMs)
+{
+    UploadResult out;
+    if (bearerToken.isEmpty()) {
+        out.errorString = QStringLiteral("missing bearer token");
+        return out;
+    }
+    if (ownerSlug.isEmpty() || projectSlug.isEmpty() || fileId.isEmpty()) {
+        out.errorString = QStringLiteral("owner slug, project slug, and fileId are required");
+        return out;
+    }
+    if (report.isEmpty()) {
+        out.errorString = QStringLiteral("report JSON is empty");
+        return out;
+    }
+
+    const QByteArray payload = QJsonDocument(report).toJson(QJsonDocument::Compact);
+    static constexpr int kMaxReportBytes = 5 * 1024 * 1024;
+    if (payload.size() > kMaxReportBytes) {
+        out.errorString = QStringLiteral("report exceeds 5 MB limit");
+        return out;
+    }
+
+    const QString path = ownerProjectPath(ownerSlug, projectSlug,
+                                          QStringLiteral("files/%1/report")
+                                              .arg(QString::fromUtf8(QUrl::toPercentEncoding(fileId))));
+    const QUrl url(apiBaseUrl() + path);
+    if (!url.isValid()) {
+        out.errorString = QStringLiteral("invalid API base URL");
+        return out;
+    }
+
+    QNetworkAccessManager nam;
+    QNetworkRequest req = authorizedJsonRequest(url, bearerToken, timeoutMs);
+
+    SentryReporter::addBreadcrumb(QStringLiteral("cloud.upload"),
+        QStringLiteral("QtMesh Cloud uploadFileReport: start fileId=%1 bytes=%2")
+            .arg(fileId, QString::number(payload.size())));
+
+    QNetworkReply* reply = nam.put(req, payload);
+    QEventLoop loop;
+    QObject::connect(reply, &QNetworkReply::finished, &loop, &QEventLoop::quit);
+    loop.exec();
+
+    out.httpStatus = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+    const QByteArray responseBody = reply->readAll();
+    const auto nerr = reply->error();
+    const QString transportErr = reply->errorString();
+    reply->deleteLater();
+
+    if (nerr != QNetworkReply::NoError || out.httpStatus < 200 || out.httpStatus >= 300) {
+        out.responseBodySnippet = trimSnippet(responseBody);
+        out.errorString = nerr != QNetworkReply::NoError ? transportErr : QStringLiteral("HTTP %1").arg(out.httpStatus);
+        if (!out.responseBodySnippet.isEmpty())
+            out.errorString += QStringLiteral(" — ") + out.responseBodySnippet;
+        SentryReporter::addBreadcrumb(QStringLiteral("cloud.upload"),
+            QStringLiteral("QtMesh Cloud uploadFileReport: failure HTTP %1").arg(out.httpStatus),
+            QStringLiteral("warning"));
+        return out;
+    }
+
+    QJsonObject root;
+    if (!parseJsonObjectBody(responseBody, root, out.errorString))
+        return out;
+    if (root.contains(QStringLiteral("ok")) && !root.value(QStringLiteral("ok")).toBool()) {
+        out.errorString = jsonErrorCode(root);
+        if (out.errorString.isEmpty())
+            out.errorString = QStringLiteral("report upload rejected");
+        out.responseBodySnippet = trimSnippet(responseBody);
+        SentryReporter::addBreadcrumb(QStringLiteral("cloud.upload"),
+            QStringLiteral("QtMesh Cloud uploadFileReport: rejected"),
+            QStringLiteral("warning"));
+        return out;
+    }
+
+    out.ok = true;
+    SentryReporter::addBreadcrumb(QStringLiteral("cloud.upload"),
+        QStringLiteral("QtMesh Cloud uploadFileReport: ok fileId=%1").arg(fileId));
+    return out;
+}
+
 QtMeshCloudClient::ManifestResult QtMeshCloudClient::fetchProjectManifest(const QString& bearerToken,
                                                                           const QString& ownerSlug,
                                                                           const QString& projectSlug,

src/QtMeshCloudClient.h

@@ -197,6 +197,15 @@ class QtMeshCloudClient {
                                                const QString& mainFileId = QString(),
                                                int timeoutMs = 30000);
 
+    /// PUT /v1/u/:owner/p/:project/files/:fileId/report — scan report after files/complete.
+    /// Body is the JSON from `ScanEngine::scanReportToJsonObject()` (max 5 MB).
+    static UploadResult uploadFileReport(const QString& bearerToken,
+                                         const QString& ownerSlug,
+                                         const QString& projectSlug,
+                                         const QString& fileId,
+                                         const QJsonObject& report,
+                                         int timeoutMs = 30000);
+
     struct ManifestResult {
         bool ok = false;
         int httpStatus = 0;