@loadmill/droid-cua 2.38.0 → 2.39.0

package/README.md

@@ -290,6 +290,7 @@ Supported CLI options include:
 - `--secrets`
 - `--record`
 - `--report`
+- `--report-metadata <path>`
 - `--no-cloud-report`
 - `--debug`
 
@@ -325,8 +326,11 @@ HTML report (`--report`):
 - With no value it saves `<test>--<date>--<time>.html` (e.g. `login--2026-06-03--16-09-20.html`) in the current directory; pass `--report <file>` to pick a filename or `--report <dir>` to pick a folder.
 - A multi-path selection writes the individual test reports plus one aggregate `Selected tests` report with a child result and timeline for every selected test. When `--report <file.html>` is used, that exact path is used for the aggregate report.
 - In the desktop app the same report is available from a run's **Share → Download HTML report** button.
-- Runs with captured screenshots also expose **Share → Generate video**. The desktop app renders a square mobile replay or 16:9 web and desktop replay locally, then prompts for a save location using `<test>--<date>--<time>--test-replay.mp4` as the suggested filename. While rendering, a compact **Background tasks** card shows progress for **Generating test replay**; it can be minimized to a task-count card or canceled without opening the save dialog.
+- Generated HTML reports opt out of Cloudflare email obfuscation so ordinary email values remain visible in hosted reports. Secret-typing values are omitted from typing logs, but may still appear in screenshots.
+- Loadmill flow entries link **Test started** to the flow's test-suite run results, including in reports generated by CI.
+- Runs with captured screenshots also expose **Share → Generate video**. The desktop app renders portrait mobile runs as square replays and landscape mobile, web, and desktop runs as 16:9 replays. Landscape Android and iOS screenshots keep a device frame sized to the captured screen instead of browser chrome. Rendering happens locally, then the app prompts for a save location using `<test>--<date>--<time>--test-replay.mp4` as the suggested filename. While rendering, a compact **Background tasks** card shows progress for **Generating test replay**; it can be minimized to a task-count card or canceled without opening the save dialog.
 - Authenticated headless runs upload their HTML report and screenshots to Loadmill by default. The Loadmill run record also includes the resolved Droid version, model, provider, Agent Pace, Aim Assist, Context Optimization, and target environment. Use `--no-cloud-report` to disable artifact upload; the Droid run record is still reported.
+- Use `--report-metadata <path>` when automation needs the exact published Loadmill run ID and last uploaded screenshot object name. Droid clears that destination when the invocation starts and writes it only after report publication succeeds, including for published failure reports.
 
 ```sh
 droid-cua run tests/login.dcua --avd adb:emulator-5554 --report ./reports

package/build/index.js

@@ -22,6 +22,7 @@ import { resolveHeadlessExecutionConfig } from "./src/cli/headless-execution-con
 import { artifactKindsForPool, resolveHeadlessTarget, scopeArtifactKindsToPool, shouldWaitForLoadmillCloudCompletion, } from "./src/cli/headless-target.js";
 import { createHeadlessDebugArtifacts } from "./src/cli/headless-debug.js";
 import { loadHeadlessInstructions } from "./src/cli/headless-instructions.js";
+import { clearLoadmillReportMetadata } from "./src/cli/loadmill-report-metadata.js";
 import { assertRunCommandPosition, getHeadlessInstructionSelectors, resolveHeadlessInstructionSelection, } from "./src/cli/headless-selection.js";
 import { runHeadlessInstructionRuns } from "./src/cli/headless-runner.js";
 import { buildLoadmillCloudDeviceConnectSummaryLines } from "./src/cli/loadmill-cloud-device-connect-summary.js";
@@ -72,6 +73,11 @@ if (args._[0] === "skill") {
         process.exit(1);
     }
 }
+const reportMetadataPath = typeof args["report-metadata"] === "string"
+    && args["report-metadata"].trim().length > 0
+    ? args["report-metadata"].trim()
+    : null;
+await clearLoadmillReportMetadata(reportMetadataPath);
 const targetConfig = resolveHeadlessTarget(args);
 let avdName = targetConfig.avdName;
 let platform = targetConfig.platform || null; // 'ios' or 'android'
@@ -98,6 +104,10 @@ const reportConfig = {
     enabled: args.report === true || (typeof args.report === "string" && args.report.trim().length > 0),
     path: typeof args.report === "string" && args.report.trim().length > 0 ? args.report.trim() : null,
     cloudEnabled: args["no-cloud-report"] !== true,
+    metadataPath: reportMetadataPath,
+    lloydJobId: typeof process.env.LLOYD_JOB_ID === "string" && process.env.LLOYD_JOB_ID.trim().length > 0
+        ? process.env.LLOYD_JOB_ID.trim()
+        : null,
 };
 const screenshotDir = path.join("droid-cua-recording-" + Date.now());
 if (recordScreenshots)

package/build/src/cli/headless-runner.js

@@ -1,5 +1,5 @@
 import path from "path";
-import { mkdir } from "fs/promises";
+import { mkdir, writeFile } from "fs/promises";
 import { getCurrentPlatform as getBrowserCurrentPlatform, getScreenshotAsBase64 as getBrowserScreenshotAsBase64, } from "../browser/connection.js";
 import { handleModelAction as handleBrowserModelAction } from "../browser/actions.js";
 import { ExecutionEngine } from "../core/execution-engine.js";
@@ -13,6 +13,7 @@ import { reportDroidCuaCiTestRunCompleted } from "../integrations/segment/droid-
 import { printCliOutput } from "../utils/console-output.js";
 import { emitDesktopDebug } from "../utils/desktop-debug.js";
 import { loadHeadlessInstructions } from "./headless-instructions.js";
+import { clearLoadmillReportMetadata } from "./loadmill-report-metadata.js";
 import { formatHeadlessTestSourceLabel } from "./headless-test-source-label.js";
 import { buildCliRunReportModel, createCapturingAddOutput, createCliAggregateRunReport, createCliRunReport, renderCliCloudReport, writeCliRunReportArtifact, } from "./headless-report.js";
 import { createRefuseReconnectConnectToBrowser } from "../desktop-shared/connection-predicates.js";
@@ -36,6 +37,24 @@ function logPendingScreenshotUploads(uploadManager, uploadSession, subject) {
         console.log(`${subject} finished. Waiting for ${pendingCount} screenshot ${uploads} to finish...`);
     }
 }
+function loadmillReportMetadata(savedRunId, publication) {
+    if (!savedRunId || !publication?.published) {
+        return null;
+    }
+    return {
+        runId: savedRunId,
+        ...(publication.lastScreenshotObjectName
+            ? { lastScreenshotObjectName: publication.lastScreenshotObjectName }
+            : {}),
+    };
+}
+async function writeLoadmillReportMetadata(filePath, metadata) {
+    if (!filePath || !metadata) {
+        return;
+    }
+    await mkdir(path.dirname(path.resolve(filePath)), { recursive: true });
+    await writeFile(filePath, `${JSON.stringify(metadata, null, 2)}\n`, { mode: 0o600 });
+}
 function getRecordScreenshotDirForTest(baseScreenshotDir, testName, isBatchRun) {
     if (!baseScreenshotDir || !isBatchRun) {
         return baseScreenshotDir;
@@ -320,9 +339,10 @@ async function runHeadlessTest({ runId, testPath, testName, instructions, sessio
         const cloudModel = cloudReportEnabled
             ? buildCliRunReportModel({ ...reportInput, events: cloudEvents })
             : null;
+        let reportPublication = null;
         if (cloudModel && reportToLoadmill && reportedRun?.savedRunId) {
             logPendingScreenshotUploads(uploadManager, cloudUploadSession, "Test");
-            await uploadManager.finish(cloudUploadSession, {
+            reportPublication = await uploadManager.finish(cloudUploadSession, {
                 savedRunId: reportedRun.savedRunId,
                 html: renderCliCloudReport(cloudModel, reportedRun.savedRunId),
             });
@@ -339,6 +359,7 @@ async function runHeadlessTest({ runId, testPath, testName, instructions, sessio
             retries: stats.retryCount ?? 0,
             localReportModel: localReport?.model ?? null,
             reportModel: cloudModel,
+            loadmillReport: loadmillReportMetadata(reportedRun?.savedRunId, reportPublication),
         };
     }
     catch (error) {
@@ -418,9 +439,10 @@ async function runHeadlessTest({ runId, testPath, testName, instructions, sessio
         const cloudModel = cloudReportEnabled
             ? buildCliRunReportModel({ ...failedReportInput, events: cloudEvents })
             : null;
+        let reportPublication = null;
         if (cloudModel && reportToLoadmill && reportedRun?.savedRunId) {
             logPendingScreenshotUploads(uploadManager, cloudUploadSession, "Test");
-            await uploadManager.finish(cloudUploadSession, {
+            reportPublication = await uploadManager.finish(cloudUploadSession, {
                 savedRunId: reportedRun.savedRunId,
                 html: renderCliCloudReport(cloudModel, reportedRun.savedRunId),
             });
@@ -439,17 +461,21 @@ async function runHeadlessTest({ runId, testPath, testName, instructions, sessio
                 retries: stats.retryCount ?? 0,
                 localReportModel: localReport?.model ?? null,
                 reportModel: cloudModel,
+                loadmillReport: loadmillReportMetadata(reportedRun?.savedRunId, reportPublication),
             };
         }
+        await writeLoadmillReportMetadata(report?.metadataPath, loadmillReportMetadata(reportedRun?.savedRunId, reportPublication));
         throw error;
     }
 }
 export async function runHeadlessInstructionRuns({ runs, instructionsTarget, session, deviceInfo, headlessConfig, appContext, runtimeContext, headlessDebug, secrets = null, recordScreenshots, screenshotDir, isBrowserTarget, isDesktopTarget = false, desktopController = null, isCloudTarget, runTarget = null, report = null, droidVersion = getDroidVersion(), runHeadlessTestImpl = runHeadlessTest, uploadManager = droidReportUploadManager, }) {
+    await clearLoadmillReportMetadata(report?.metadataPath);
     const resolvedRunTarget = runTarget ?? { isBrowserTarget, isDesktopTarget, isCloudTarget };
     const runConfiguration = buildDroidRunConfiguration({
         droidVersion,
         runtimeConfig: runtimeContext.config,
         aimAssistMode: headlessConfig.aimAssistMode,
+        lloydJobId: report?.lloydJobId,
     });
     const isBatchRun = ["directory", "selection", "scenario"].includes(instructionsTarget?.type);
     const cloudReportEnabled = report?.cloudEnabled !== false &&
@@ -470,6 +496,7 @@ export async function runHeadlessInstructionRuns({ runs, instructionsTarget, ses
         console.log(`\nRunning ${runs.length} tests from: ${instructionsTarget.path}\n`);
     }
     let failures = 0;
+    let reportMetadata = null;
     const batchStartedAt = Date.now();
     const aggregateStats = {
         durationMs: 0,
@@ -530,6 +557,7 @@ export async function runHeadlessInstructionRuns({ runs, instructionsTarget, ses
             if (result.reportModel) {
                 aggregateReportModels.push(result.reportModel);
             }
+            reportMetadata = result.loadmillReport ?? reportMetadata;
             if (result.localReportModel) {
                 aggregateLocalReportModels.push(result.localReportModel);
             }
@@ -642,12 +670,14 @@ export async function runHeadlessInstructionRuns({ runs, instructionsTarget, ses
                 childModels: aggregateReportModels,
             });
             logPendingScreenshotUploads(uploadManager, cloudUploadSession, "Run");
-            await uploadManager.finish(cloudUploadSession, {
+            const publication = await uploadManager.finish(cloudUploadSession, {
                 savedRunId: reportedRun.savedRunId,
                 html: renderCliCloudReport(aggregateReport.model, reportedRun.savedRunId),
             });
+            reportMetadata = loadmillReportMetadata(reportedRun.savedRunId, publication);
         }
     }
+    await writeLoadmillReportMetadata(report?.metadataPath, reportMetadata);
     return {
         exitCode: failures === 0 ? 0 : 1,
         failures

package/build/src/cli/loadmill-report-metadata.js

@@ -0,0 +1,7 @@
+import { rm } from "fs/promises";
+export async function clearLoadmillReportMetadata(filePath) {
+    if (!filePath) {
+        return;
+    }
+    await rm(filePath, { force: true });
+}

package/build/src/commands/help.js

@@ -54,6 +54,7 @@ export async function handleHelp(args, session, context) {
     addOutput({ type: 'info', text: '  --explain              Explain non-obvious decisions and completion evidence' });
     addOutput({ type: 'info', text: '  --report [path]        Save a self-contained HTML report locally' });
     addOutput({ type: 'info', text: '  --no-cloud-report      Skip uploading the HTML report and screenshots to Loadmill' });
+    addOutput({ type: 'info', text: '  --report-metadata <path> Write uploaded Loadmill report metadata as JSON' });
     addOutput({ type: 'info', text: '  --debug                Enable structured JSONL debug artifacts' });
     addOutput({ type: 'info', text: '' });
     addOutput({ type: 'info', text: 'Interactive commands:' });

package/build/src/core/report/render-html-report.js

@@ -255,12 +255,36 @@ function renderCloudCard(events) {
 }
 function renderLoadmillCard(events) {
     const lines = events.map((event) => event.text.replace(/^\[Loadmill\]\s*/, "").trim());
+    const runId = events.map((event) => event.payload?.loadmillSuiteRunId)
+        .find((value) => typeof value === "string" && value.trim()) ??
+        lines.map((line) => line.match(/Test started \(ID:\s*([^)]+)\)/i)?.[1]?.trim() ||
+            line.match(/Run ID:\s*(.+)$/i)?.[1]?.trim()).find(Boolean);
+    const baseUrl = events.map((event) => event.payload?.loadmillBaseUrl)
+        .find((value) => typeof value === "string" && value.trim()) ?? "https://app.loadmill.com";
+    let runUrl = null;
+    if (runId) {
+        try {
+            const url = new URL(`${baseUrl.trim().replace(/\/$/, "")}/app/api-tests/test-suite-runs/${encodeURIComponent(runId.trim())}`);
+            if (url.protocol === "https:" || url.protocol === "http:")
+                runUrl = url.href;
+        }
+        catch {
+            // Keep the original log text when the recorded base URL is invalid.
+        }
+    }
+    const renderedLines = lines.map((line) => {
+        const started = line.match(/^Test started \(ID:\s*([^)]+)\)\.(.*)$/i);
+        const text = started && runUrl
+            ? `<a href="${escapeHtml(runUrl)}" target="_blank" rel="noreferrer">Test started</a>${renderLinkedText(started[2])}`
+            : renderLinkedText(line);
+        return `<div>${text}</div>`;
+    });
     const failed = events.some((event) => /\[Loadmill\]\s*FAILED|^Error:/i.test(event.text));
     const passed = !failed && events.some((event) => /\bpassed\b/i.test(event.text));
     const status = failed ? "failed" : passed ? "passed" : "running";
     return `<details class="dc-special dc-loadmill"${passed ? "" : " open"}>
   <summary><span class="dc-special-title">${ICONS.loadmill}Loadmill Flow</span><span class="dc-pill dc-pill-${status}">${status}</span></summary>
-  <div class="dc-special-body">${lines.map((line) => `<div>${renderLinkedText(line)}</div>`).join("")}</div>
+  <div class="dc-special-body">${renderedLines.join("")}</div>
 </details>`;
 }
 function renderTimeline(events, shots, warnings = []) {
@@ -464,10 +488,12 @@ ${STYLES}
 </style>
 </head>
 <body>
+<!--email_off-->
 <div class="dc-wrap" id="dc-top">
 <div class="dc-header"><div class="dc-title">Run Details: ${escapeHtml(heading)}</div><span class="dc-pill dc-pill-${escapeHtml(model.status)}">${escapeHtml(runStatusLabel(model.status))}</span></div>
 ${body}
 </div>${lightboxes ? `\n${lightboxes}` : ""}${script ? `\n${script}` : ""}
+<!--/email_off-->
 </body>
 </html>`;
 }

package/build/src/device/android/connection.js

@@ -5,6 +5,18 @@ import { emitDesktopDebug } from "../../utils/desktop-debug.js";
 import { execAdb, execEmulator, spawnAdb, spawnEmulator } from "./tools.js";
 const AVD_READY_TIMEOUT_MS = 180000;
 const AVD_READY_TIMEOUT_SECONDS = AVD_READY_TIMEOUT_MS / 1000;
+const TARGET_SCALED_SHORT_EDGE = 400;
+export function calculateScaledScreenDimensions(width, height) {
+    const shortestEdge = Math.min(width, height);
+    const scale = shortestEdge > TARGET_SCALED_SHORT_EDGE
+        ? TARGET_SCALED_SHORT_EDGE / shortestEdge
+        : 1.0;
+    return {
+        scaledWidth: Math.round(width * scale),
+        scaledHeight: Math.round(height * scale),
+        scale,
+    };
+}
 async function listConnectedDevices() {
     const { stdout } = await execAdb(["devices"]);
     return stdout
@@ -238,10 +250,7 @@ export async function getDeviceInfo(deviceId) {
         process.exit(1);
     }
     const [_, width, height] = match.map(Number);
-    const targetWidth = 400;
-    const scale = width > targetWidth ? targetWidth / width : 1.0;
-    const scaledWidth = Math.round(width * scale);
-    const scaledHeight = Math.round(height * scale);
+    const { scaledWidth, scaledHeight, scale } = calculateScaledScreenDimensions(width, height);
     const [{ stdout: manufacturerRaw }, { stdout: modelRaw }, { stdout: deviceNameRaw }] = await Promise.all([
         execAdb(["-s", deviceId, "shell", "getprop", "ro.product.manufacturer"]),
         execAdb(["-s", deviceId, "shell", "getprop", "ro.product.model"]),

package/build/src/device/interface.js

@@ -31,7 +31,7 @@
  *
  * getDeviceInfo(deviceId: string): Promise<DeviceInfo>
  *   - Gets screen dimensions and calculates scale factor
- *   - Target width for scaling is 400px
+ *   - Local Android screenshots target a 400px shortest edge
  *
  * getScreenshotAsBase64(deviceId: string, deviceInfo: DeviceInfo): Promise<string>
  *   - Captures current screen state

package/build/src/integrations/loadmill/report-upload-manager.js

@@ -55,6 +55,7 @@ export class DroidReportUploadManager {
             onWarning,
             sequence: 0,
             screenshotCount: 0,
+            lastScreenshotObjectName: null,
             deduplication: new Map(),
             pending: new Set(),
             failed: false,
@@ -73,6 +74,7 @@ export class DroidReportUploadManager {
         const hash = createHash("sha256").update(dataUrl).digest("hex");
         const existing = session.deduplication.get(hash);
         if (existing) {
+            session.lastScreenshotObjectName = existing;
             return existing;
         }
         const body = decodeScreenshot(dataUrl);
@@ -90,6 +92,7 @@ export class DroidReportUploadManager {
         }
         const name = `screenshots/${String(++session.sequence).padStart(4, "0")}.png`;
         session.screenshotCount += 1;
+        session.lastScreenshotObjectName = name;
         session.deduplication.set(hash, name);
         this.#enqueue(session, { name, body, contentType: "image/png" });
         return name;
@@ -139,7 +142,11 @@ export class DroidReportUploadManager {
             key,
             screenshotCount: session.screenshotCount,
         });
-        return { published: true, key };
+        return {
+            published: true,
+            key,
+            lastScreenshotObjectName: session.lastScreenshotObjectName,
+        };
     }
     async waitForSession(session) {
         while (session?.pending?.size) {

package/build/src/integrations/loadmill/run-reporter.js

@@ -61,6 +61,7 @@ export function normalizeDroidRunStatus({ status = null, outcome = null, success
  *     contextOptimizationThreshold?: number | null,
  *   } | null,
  *   aimAssistMode?: string | null,
+ *   lloydJobId?: string | null,
  * }} input
  * @returns {{
  *   droidVersion: string | null,
@@ -68,17 +69,19 @@ export function normalizeDroidRunStatus({ status = null, outcome = null, success
  *   llmProviderMode: string | null | undefined,
  *   stepDelayMs: number | null | undefined,
  *   aimAssistMode: string | null,
+ *   lloydJobId?: string,
  *   contextOptimizationEnabled: boolean | null | undefined,
  *   contextOptimizationThreshold: number | null | undefined,
  * }}
  */
-export function buildDroidRunConfiguration({ droidVersion = null, runtimeConfig = null, aimAssistMode = null, } = {}) {
+export function buildDroidRunConfiguration({ droidVersion = null, runtimeConfig = null, aimAssistMode = null, lloydJobId = null, } = {}) {
     return {
         droidVersion,
         model: runtimeConfig?.cuaModel,
         llmProviderMode: runtimeConfig?.llmProviderMode,
         stepDelayMs: runtimeConfig?.stepDelayMs,
         aimAssistMode,
+        ...(lloydJobId ? { lloydJobId } : {}),
         contextOptimizationEnabled: runtimeConfig?.contextOptimizationEnabled,
         contextOptimizationThreshold: runtimeConfig?.contextOptimizationThreshold,
     };
@@ -108,6 +111,7 @@ export function buildDroidRunReportPayload(input = {}) {
         assertionsFailed: nonNegativeIntegerOrNull(input.assertionsFailed),
         retries: nonNegativeIntegerOrNull(input.retries),
         error: trimToNull(input.error),
+        lloydJobId: trimToNull(input.lloydJobId),
     };
     for (const key of Object.keys(payload)) {
         if (payload[key] == null) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loadmill/droid-cua",
-  "version": "2.38.0",
+  "version": "2.39.0",
   "description": "AI-powered Android testing agent using OpenAI's computer-use model and ADB",
   "main": "build/index.js",
   "type": "module",

package/skill/droid-cua/references/running-and-healing.md

@@ -20,6 +20,8 @@ All Loadmill models require `LOADMILL_API_TOKEN`. Do not switch from Pulse to Sm
 
 Include `--report reports/<test-name>.html` for normal test runs unless the user opts out. Prefer an explicit filename over a directory so the result is easy to locate. Add `--debug` for every agent-observed run: it writes the screenshots needed for live progress updates as well as diagnosis.
 
+When downstream automation needs an exact Loadmill handoff, add `--report-metadata reports/<test-name>.json`. Read it only after Droid exits. Droid clears the destination at run start and writes the saved run ID plus the last uploaded screenshot object name only after cloud report publication succeeds, including when a failed test's report was published. Do not infer the run or screenshot by searching recent Loadmill runs when this file was requested but absent.
+
 ```sh
 # Attached Android device or running emulator
 droid-cua run tests/example.dcua --llm-provider loadmill --cua-model loadmill-pulse --avd adb:<serial> --context tests/context.md --debug --report reports/example.html
@@ -105,6 +107,7 @@ When the command completes, show the final safe screenshot in addition to the re
 - Exit `130`: interrupted run.
 - `--debug`: writes structured execution JSONL and adjacent screenshots under `logs/`.
 - `--report`: writes a self-contained HTML report. Prefer an explicit `.html` file path such as `reports/example.html` so the evidence location is unambiguous.
+- `--report-metadata`: writes the exact published Loadmill run and last screenshot handoff for downstream automation. Treat an absent file as no successful publication for the current invocation.
 
 After the run, verify that the report exists and resolve its absolute path. Open it for the user when the agent environment supports local-file opening and policy permits; otherwise provide a clickable local-file link or the absolute path so the user can open it directly.