@loadmill/droid-cua 2.17.0 → 2.18.0

package/build/src/core/report/run-log-model.js

@@ -0,0 +1,144 @@
+// Pure leaf classifier predicates for execution log events.
+// Shared by the Desktop App (log-utils.ts re-exports these) and the HTML report renderer.
+// No I/O, no React, no side effects.
+import { classifyCaptureSource } from "../capture-sources.js";
+export function captureSourceOf(line) {
+    const captureSource = line.payload?.captureSource;
+    return typeof captureSource === "string" && captureSource.trim().length > 0 ? captureSource : null;
+}
+export function mediaKindOf(line) {
+    const captureSource = captureSourceOf(line);
+    const classification = classifyCaptureSource(captureSource);
+    const mediaKind = classification.mediaKind;
+    if (mediaKind === "hidden-debug" || mediaKind === "click-annotation" || mediaKind === "screenshot") {
+        return mediaKind;
+    }
+    // Backcompat bridge for older logs and reports that predate captureSource normalization.
+    const toolName = line.payload?.toolName;
+    if (toolName === "preview_click") {
+        return "hidden-debug";
+    }
+    const hasScreenshot = typeof line.payload?.screenshotDataUrl === "string" ||
+        typeof line.payload?.screenshotPath === "string";
+    if (!hasScreenshot) {
+        return "none";
+    }
+    if (line.eventType === "screenshot_captured" || line.eventType === "assertion_result") {
+        return "screenshot";
+    }
+    if (line.kind === "action") {
+        return "click-annotation";
+    }
+    return "none";
+}
+export function isHiddenExecutionLogEvent(line) {
+    return mediaKindOf(line) === "hidden-debug";
+}
+export function isGalleryMediaEvent(line) {
+    const mediaKind = mediaKindOf(line);
+    return mediaKind === "click-annotation" || mediaKind === "screenshot";
+}
+export function cleanAssertionDetails(rawDetails, assertion, passed) {
+    if (!rawDetails)
+        return null;
+    let details = rawDetails
+        .replace(/\[(Assertion|Assistant)\]\s*/gi, "")
+        .replace(/\r/g, "")
+        .trim();
+    const lines = details
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0 && !/assertion result:/i.test(line));
+    details = lines.join(" ").replace(/\s{2,}/g, " ").trim();
+    if (!passed && /assertion result:\s*pass/i.test(rawDetails)) {
+        details = details.replace(/assertion result:\s*pass.*$/i, "").trim();
+    }
+    if (passed && /assertion result:\s*fail/i.test(rawDetails)) {
+        details = details.replace(/assertion result:\s*fail.*$/i, "").trim();
+    }
+    if (details.toLowerCase() === assertion.trim().toLowerCase())
+        return null;
+    return details.length > 0 ? details : null;
+}
+export function assertionData(event) {
+    if (event.eventType !== "assertion_result")
+        return null;
+    const payload = event.payload ?? {};
+    const assertion = typeof payload.assertion === "string" && payload.assertion.trim().length > 0
+        ? payload.assertion
+        : event.text;
+    const passed = Boolean(payload.passed);
+    const rawDetails = typeof payload.details === "string" && payload.details.trim().length > 0
+        ? payload.details
+        : null;
+    return { assertion, details: cleanAssertionDetails(rawDetails, assertion, passed), passed };
+}
+export function runSummaryData(event) {
+    if (event.eventType !== "run_finished")
+        return null;
+    const payload = event.payload ?? {};
+    const success = Boolean(payload.success);
+    const error = typeof payload.error === "string" && payload.error.trim().length > 0 ? payload.error : null;
+    const stopped = !success && Boolean(error && error.toLowerCase().includes("stopped by user"));
+    const isAssertionFailure = Boolean(error && error.startsWith("Assertion failed:"));
+    return {
+        status: success ? "passed" : stopped ? "stopped" : isAssertionFailure ? "failed" : "errored",
+        durationMs: typeof payload.durationMs === "number" ? payload.durationMs : null,
+        instructionsTotal: typeof payload.instructionsTotal === "number" ? payload.instructionsTotal : null,
+        instructionsCompleted: typeof payload.instructionsCompleted === "number" ? payload.instructionsCompleted : null,
+        assertionsPassed: typeof payload.assertionsPassed === "number" ? payload.assertionsPassed : null,
+        assertionsFailed: typeof payload.assertionsFailed === "number" ? payload.assertionsFailed : null,
+        retries: typeof payload.retries === "number" ? payload.retries : null,
+        error,
+    };
+}
+export function formatDuration(ms) {
+    if (ms === null || ms === undefined)
+        return "n/a";
+    const totalSeconds = ms / 1000;
+    if (totalSeconds < 60)
+        return `${totalSeconds.toFixed(1)}s`;
+    const wholeSeconds = Math.floor(totalSeconds);
+    const minutes = Math.floor(wholeSeconds / 60);
+    const seconds = wholeSeconds % 60;
+    if (minutes < 60)
+        return `${minutes}m ${seconds.toString().padStart(2, "0")}s`;
+    const hours = Math.floor(minutes / 60);
+    const remainingMinutes = minutes % 60;
+    return `${hours}h ${remainingMinutes.toString().padStart(2, "0")}m`;
+}
+export function isAssistantAssertionSummary(event) {
+    if (!(event.eventType === "assistant_message" || event.kind === "assistant"))
+        return false;
+    const text = event.text.toLowerCase();
+    return text.includes("assertion result: pass") || text.includes("assertion result: fail");
+}
+export function hasNearbyAssertionCard(events, index) {
+    const current = events[index];
+    const windowStart = Math.max(0, index - 3);
+    const windowEnd = Math.min(events.length - 1, index + 3);
+    for (let i = windowStart; i <= windowEnd; i++) {
+        if (i === index)
+            continue;
+        const candidate = events[i];
+        if (candidate.eventType !== "assertion_result")
+            continue;
+        if (current.stepId && candidate.stepId) {
+            if (current.stepId === candidate.stepId)
+                return true;
+            continue;
+        }
+        return true;
+    }
+    return false;
+}
+export function isDuplicateAssertionLine(event, previous) {
+    if (event.eventType !== "assertion_result" || !previous || previous.eventType !== "assertion_result") {
+        return false;
+    }
+    const current = assertionData(event);
+    const prev = assertionData(previous);
+    if (!current || !prev)
+        return false;
+    return current.assertion === prev.assertion && current.passed === prev.passed;
+}

package/build/src/core/report/run-report-model.js

@@ -0,0 +1,143 @@
+// The single, shared model-assembler for run reports. Both producers — the XML/Desktop
+// path (parse-run-report.js) and the CLI path (headless-report.js) — acquire raw run data
+// their own way (parse stored JUnit XML vs. capture live events), then delegate ALL model
+// assembly to the pure functions here. This guarantees the two paths derive status,
+// success rate, failure shape, and event normalization identically (structural parity,
+// not coincidence), so the shared renderer produces the same HTML from either source.
+//
+// Pure: no I/O, no XML, no React. The canonical normalized event shape is
+//   { ts, kind, text, eventType?, actionType?, payload? }
+// and the assembled model is a RunReportModel (see assembleRunReportModel).
+const VALID_KINDS = new Set([
+    "user",
+    "assistant",
+    "reasoning",
+    "action",
+    "warning",
+    "info",
+    "error",
+    "success",
+    "system",
+    "muted",
+]);
+const VALID_EVENTS = new Set([
+    "run_started",
+    "instruction_started",
+    "reasoning",
+    "assistant_message",
+    "tool_call",
+    "screenshot_captured",
+    "assertion_result",
+    "retry",
+    "input_request",
+    "run_finished",
+    "error",
+    "system_message",
+    "design_started",
+    "design_status",
+    "design_waiting_for_input",
+    "design_user_input",
+    "design_generated_script",
+    "design_saved",
+    "design_error",
+    "design_finished",
+]);
+const VALID_ACTIONS = new Set([
+    "click",
+    "double_click",
+    "drag",
+    "scroll",
+    "type",
+    "keypress",
+    "wait",
+    "screenshot",
+    "move",
+]);
+// Normalizes one raw event (already mapped to canonical field names) into the shared
+// shape, validating kind/eventType/actionType against the known sets and dropping events
+// with no usable text. Returns null for a dropped event (and pushes a warning, if a
+// `warnings` array is provided). Callers map their producer-specific field names
+// (NDJSON `event`/`action`, CLI `type`) to `eventType`/`actionType`/`kind` before calling.
+export function normalizeEvent(value, { fallbackTs = null, warnings } = {}) {
+    const text = typeof value.text === "string" ? value.text : null;
+    if (!text || !text.trim()) {
+        warnings?.push("Skipped one event line due to missing text.");
+        return null;
+    }
+    const ts = typeof value.ts === "string" && value.ts.trim().length > 0 ? value.ts : fallbackTs;
+    const kind = typeof value.kind === "string" && VALID_KINDS.has(value.kind) ? value.kind : "info";
+    const eventType = typeof value.eventType === "string" && VALID_EVENTS.has(value.eventType) ? value.eventType : undefined;
+    const actionType = typeof value.actionType === "string" && VALID_ACTIONS.has(value.actionType) ? value.actionType : undefined;
+    const payload = value.payload && typeof value.payload === "object" && !Array.isArray(value.payload)
+        ? value.payload
+        : undefined;
+    return { ts, kind, text, eventType, actionType, payload };
+}
+// Maps a list of raw events through normalizeEvent, dropping the ones that fail.
+export function normalizeEvents(values, options = {}) {
+    const events = [];
+    for (const value of values) {
+        const event = normalizeEvent(value, options);
+        if (event)
+            events.push(event);
+    }
+    return events;
+}
+// The single status precedence ladder: error > fail > stopped > skipped > pass.
+// `failureKind` is the kind of any parsed <failure>/<error> node (XML) or the CLI's
+// derived failure kind; it lets a run with no count attributes still resolve correctly.
+export function deriveRunStatus({ tests = 0, failures = 0, errors = 0, skipped = 0, stopped = false, hasSkippedNode = false, failureKind, } = {}) {
+    if (errors > 0 || failureKind === "error")
+        return "error";
+    if (failures > 0 || failureKind === "failure")
+        return "fail";
+    if (stopped)
+        return "stopped";
+    if (skipped >= tests || (hasSkippedNode && tests <= 1))
+        return "skipped";
+    return "pass";
+}
+// The single success-rate formula: passed / tests, falling back to status when there are
+// no test counts. `passed` = tests minus failures/errors/skipped (clamped at 0).
+export function computeSuccessRate({ tests = 0, failures = 0, errors = 0, skipped = 0, status } = {}) {
+    const passed = Math.max(0, tests - failures - errors - skipped);
+    return tests > 0 ? (passed / tests) * 100 : status === "pass" ? 100 : 0;
+}
+// The single failureOrError constructor. Returns undefined when there is no failure kind.
+export function makeFailureOrError({ kind, type, message, body } = {}) {
+    if (!kind)
+        return undefined;
+    return { kind, type, message, body };
+}
+// The single run_finished payload contract — the shape the shared renderer's
+// runSummaryData() consumes. Producers map their own stat names to these canonical fields.
+export function buildRunFinishedPayload({ success, error, durationMs, instructionsTotal, instructionsCompleted, actionsTotal, assertionsPassed, assertionsFailed, retries, } = {}) {
+    return {
+        success: Boolean(success),
+        error: error ?? null,
+        durationMs,
+        instructionsTotal,
+        instructionsCompleted: instructionsCompleted ?? 0,
+        actionsTotal: actionsTotal ?? 0,
+        assertionsPassed: assertionsPassed ?? 0,
+        assertionsFailed: assertionsFailed ?? 0,
+        retries: retries ?? 0,
+    };
+}
+// Assembles the final RunReportModel from already-derived parts. Both producers end here so
+// the top-level shape is identical regardless of source.
+export function assembleRunReportModel({ suiteName = null, testName = null, timestamp = null, durationSeconds = null, status, testCases, successRate, failureOrError, events = [], childTests, warnings = [], } = {}) {
+    return {
+        suiteName,
+        testName,
+        timestamp,
+        durationSeconds,
+        status,
+        testCases,
+        successRate,
+        failureOrError,
+        events,
+        childTests,
+        warnings,
+    };
+}

package/build/src/core/secrets.js

@@ -0,0 +1,116 @@
+import path from "node:path";
+import { readFile } from "node:fs/promises";
+import { parse as parseDotenv } from "dotenv";
+export const SECRETS_FILE_NAME = ".secrets";
+export function normalizeSecretKeys(keys) {
+    if (!Array.isArray(keys))
+        return [];
+    return keys
+        .map((key) => (typeof key === "string" ? key.trim() : ""))
+        .filter(Boolean)
+        .sort((a, b) => a.localeCompare(b));
+}
+function sortedKeys(secretsByKey = {}) {
+    return normalizeSecretKeys(Object.keys(secretsByKey));
+}
+function mergeSecretMaps(...maps) {
+    const merged = {};
+    for (const map of maps) {
+        if (!map || typeof map !== "object")
+            continue;
+        for (const [key, value] of Object.entries(map)) {
+            if (!key)
+                continue;
+            merged[key] = String(value ?? "");
+        }
+    }
+    return merged;
+}
+export function getDefaultSecretsPath(basePath = process.cwd()) {
+    return path.join(basePath, SECRETS_FILE_NAME);
+}
+export function parseSecretsOverrideString(rawValue) {
+    if (rawValue == null || rawValue === "") {
+        return {};
+    }
+    if (typeof rawValue !== "string") {
+        throw new Error("--secrets must be a comma-separated KEY=value string.");
+    }
+    const parsed = {};
+    for (const rawEntry of rawValue.split(",")) {
+        const entry = rawEntry.trim();
+        if (!entry)
+            continue;
+        const separatorIndex = entry.indexOf("=");
+        if (separatorIndex < 0) {
+            throw new Error("--secrets entries must use KEY=value format.");
+        }
+        const key = entry.slice(0, separatorIndex).trim();
+        if (!key) {
+            throw new Error("--secrets entries must include a non-empty key.");
+        }
+        parsed[key] = entry.slice(separatorIndex + 1);
+    }
+    return parsed;
+}
+export async function loadSecretsFile(filePath) {
+    if (!filePath) {
+        return {
+            status: "missing",
+            secretsByKey: {},
+            path: null,
+            message: null,
+        };
+    }
+    try {
+        const content = await readFile(filePath, "utf-8");
+        return {
+            status: "loaded",
+            secretsByKey: parseDotenv(content),
+            path: filePath,
+            message: null,
+        };
+    }
+    catch (error) {
+        if (error?.code === "ENOENT") {
+            return {
+                status: "missing",
+                secretsByKey: {},
+                path: filePath,
+                message: null,
+            };
+        }
+        const message = error instanceof Error ? error.message : "Unknown file read error.";
+        return {
+            status: "failed",
+            secretsByKey: {},
+            path: filePath,
+            message,
+        };
+    }
+}
+/**
+ * @param {Object} [options]
+ * @param {string|null} [options.secretsPath] Path to a `.secrets` file. Pass `null`
+ *   to skip file loading entirely (resolves to no file-based secrets).
+ * @param {string|null} [options.cliSecrets] Comma-separated KEY=value overrides.
+ */
+export async function resolveExecutionSecrets({ secretsPath = getDefaultSecretsPath(), cliSecrets = null, } = {}) {
+    const fileResult = await loadSecretsFile(secretsPath);
+    if (fileResult.status === "failed") {
+        throw new Error(`Could not read secrets file ${fileResult.path}: ${fileResult.message}`);
+    }
+    const cliSecretsByKey = parseSecretsOverrideString(cliSecrets);
+    const secretsByKey = mergeSecretMaps(fileResult.secretsByKey, cliSecretsByKey);
+    const availableSecretKeys = sortedKeys(secretsByKey);
+    return {
+        secretsByKey,
+        availableSecretKeys,
+        sourceMetadata: {
+            filePath: fileResult.path,
+            fileStatus: fileResult.status,
+            fileKeyCount: sortedKeys(fileResult.secretsByKey).length,
+            cliKeyCount: sortedKeys(cliSecretsByKey).length,
+        },
+    };
+}

package/build/src/core/tool-handlers/close-current-tab.js

@@ -2,7 +2,7 @@ import { normalizeBrowserInfoForSession } from "../../browser/normalize.js";
 import { CAPTURE_SOURCES } from "../capture-sources.js";
 import { printCliOutput } from "../../utils/console-output.js";
 import { updateBrowserSessionInfo } from "./browser-session.js";
-import { buildFunctionCallOutputItem, buildPreviewOutputContent, buildTextToolOutputItem, } from "./utils.js";
+import { buildFunctionCallOutputItem, buildToolOutputContent, buildTextToolOutputItem, } from "./utils.js";
 export async function handleCloseCurrentTabToolCall({ engine, callId, context = null, stepContext = null }) {
     const session = engine.session;
     if (session?.targetKind !== "browser" && session?.deviceInfo?.platform !== "browser") {
@@ -44,9 +44,9 @@ export async function handleCloseCurrentTabToolCall({ engine, callId, context =
     });
     return {
         kind: "continue",
-        outputItem: buildFunctionCallOutputItem(callId, buildPreviewOutputContent({
+        outputItem: buildFunctionCallOutputItem(callId, buildToolOutputContent({
             text: result.message,
-            annotatedScreenshotBase64: screenshotBase64,
+            imageBase64: screenshotBase64,
         })),
         currentScreenshot,
     };

package/build/src/core/tool-handlers/navigate.js

@@ -3,7 +3,7 @@ import { buildExecutionNavigationRecoveryPrompt } from "../../prompts/execution.
 import { emitDesktopDebug } from "../../utils/desktop-debug.js";
 import { printCliOutput } from "../../utils/console-output.js";
 import { updateBrowserSessionInfo } from "./browser-session.js";
-import { buildDebugContext, buildFunctionCallOutputItem, buildPreviewOutputContent, buildTextToolOutputItem, isDesignContext, parseStringToolArgument, } from "./utils.js";
+import { buildDebugContext, buildFunctionCallOutputItem, buildToolOutputContent, buildTextToolOutputItem, isDesignContext, parseStringToolArgument, } from "./utils.js";
 export async function handleNavigateToolCall({ engine, callId, argumentsText, context = null, stepContext = null }) {
     const session = engine.session;
     const parsed = parseStringToolArgument(argumentsText, "target", "navigate");
@@ -69,9 +69,9 @@ export async function handleNavigateToolCall({ engine, callId, argumentsText, co
             const screenshotBase64 = await engine.getScreenshotAsBase64(session.deviceId, session.deviceInfo);
             return {
                 kind: "continue",
-                outputItem: buildFunctionCallOutputItem(callId, buildPreviewOutputContent({
+                outputItem: buildFunctionCallOutputItem(callId, buildToolOutputContent({
                     text: `Navigation complete: ${normalizedUrl}`,
-                    annotatedScreenshotBase64: screenshotBase64,
+                    imageBase64: screenshotBase64,
                 })),
             };
         }

package/build/src/core/tool-handlers/preview-click.js

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { createAnnotatedScreenshotFromBase64 } from "../../utils/run-screenshot-recorder.js";
 import { CAPTURE_SOURCES } from "../capture-sources.js";
-import { buildFunctionCallOutputItem, buildPreviewOutputContent, } from "./utils.js";
+import { buildFunctionCallOutputItem, buildToolOutputContent, } from "./utils.js";
 function buildPreviewClickValidationError(argumentsText) {
     if (!argumentsText || typeof argumentsText !== "string") {
         return "Invalid preview_click arguments: expected a JSON object with numeric x and y.";
@@ -42,7 +42,7 @@ export async function handlePreviewClick({ engine, callId, argumentsText, contex
     const session = engine.session;
     const parsedArguments = parsePreviewClickArguments(argumentsText);
     if (!parsedArguments.ok) {
-        return continueWith(buildFunctionCallOutputItem(callId, buildPreviewOutputContent({ text: parsedArguments.message })));
+        return continueWith(buildFunctionCallOutputItem(callId, buildToolOutputContent({ text: parsedArguments.message })));
     }
     try {
         const screenshotBase64 = await engine.getScreenshotAsBase64(session.deviceId, session.deviceInfo);
@@ -52,7 +52,7 @@ export async function handlePreviewClick({ engine, callId, argumentsText, contex
             style: "preview",
         });
         if (!previewResult?.screenshotBase64 || !previewResult?.marker) {
-            return continueWith(buildFunctionCallOutputItem(callId, buildPreviewOutputContent({
+            return continueWith(buildFunctionCallOutputItem(callId, buildToolOutputContent({
                 text: "preview_click failed: could not annotate the current screenshot.",
             })));
         }
@@ -99,13 +99,13 @@ export async function handlePreviewClick({ engine, callId, argumentsText, contex
                 },
             });
         }
-        return continueWith(buildFunctionCallOutputItem(callId, buildPreviewOutputContent({
+        return continueWith(buildFunctionCallOutputItem(callId, buildToolOutputContent({
             text: previewText,
-            annotatedScreenshotBase64: previewResult.screenshotBase64,
+            imageBase64: previewResult.screenshotBase64,
         })));
     }
     catch (error) {
-        return continueWith(buildFunctionCallOutputItem(callId, buildPreviewOutputContent({
+        return continueWith(buildFunctionCallOutputItem(callId, buildToolOutputContent({
             text: `preview_click failed: ${error instanceof Error ? error.message : "unable to capture or annotate the current screen."}`,
         })));
     }

package/build/src/core/tool-handlers/type-sensitive-text.js

@@ -0,0 +1,62 @@
+import { randomUUID } from "node:crypto";
+import { CAPTURE_SOURCES } from "../capture-sources.js";
+import { buildFunctionCallOutputItem, buildToolOutputContent, buildTextToolOutputItem, parseStringToolArgument, } from "./utils.js";
+export async function handleTypeSensitiveTextToolCall({ engine, callId, argumentsText, context = null, stepContext = null }) {
+    const parsed = parseStringToolArgument(argumentsText, "key", "type_sensitive_text");
+    if (!parsed.ok) {
+        return {
+            kind: "continue",
+            outputItem: buildTextToolOutputItem(callId, parsed.message),
+        };
+    }
+    const key = parsed.value;
+    const secretsByKey = engine.secretsByKey && typeof engine.secretsByKey === "object" ? engine.secretsByKey : {};
+    if (!Object.prototype.hasOwnProperty.call(secretsByKey, key)) {
+        return {
+            kind: "continue",
+            outputItem: buildTextToolOutputItem(callId, `Secret key not found: ${key}`),
+        };
+    }
+    const action = {
+        type: "type",
+        text: String(secretsByKey[key] ?? ""),
+        sensitive: true,
+        sensitiveKey: key,
+    };
+    try {
+        const result = await engine.handleModelAction(engine.session.deviceId, action, engine.session.deviceInfo.scale, {
+            ...context,
+            stepId: stepContext?.stepId,
+            instructionIndex: stepContext?.instructionIndex,
+            eventId: randomUUID(),
+        });
+        if (result?.success === false) {
+            return {
+                kind: "fail",
+                error: `Sensitive typing failed for ${key}.`,
+            };
+        }
+    }
+    catch {
+        return {
+            kind: "fail",
+            error: `Sensitive typing failed for ${key}.`,
+        };
+    }
+    const screenshotBase64 = await engine.getScreenshotAsBase64(engine.session.deviceId, engine.session.deviceInfo);
+    const currentScreenshot = await engine.recordScreenshot(screenshotBase64, {
+        runId: context?.runId,
+        sessionId: context?.sessionId,
+        stepId: stepContext?.stepId,
+        instructionIndex: stepContext?.instructionIndex,
+        captureSource: CAPTURE_SOURCES.CALL_OUTPUT_POST_ACTION,
+    });
+    return {
+        kind: "continue",
+        outputItem: buildFunctionCallOutputItem(callId, buildToolOutputContent({
+            text: `Typed secret: ${key}`,
+            imageBase64: screenshotBase64,
+        })),
+        currentScreenshot,
+    };
+}

package/build/src/core/tool-handlers/utils.js

@@ -45,12 +45,12 @@ export function buildFunctionCallOutputItem(callId, output) {
 export function buildTextToolOutputItem(callId, text) {
     return buildFunctionCallOutputItem(callId, [{ type: "input_text", text }]);
 }
-export function buildPreviewOutputContent({ text, annotatedScreenshotBase64 = null }) {
+export function buildToolOutputContent({ text, imageBase64 = null }) {
     const content = [{ type: "input_text", text }];
-    if (annotatedScreenshotBase64) {
+    if (imageBase64) {
         content.push({
             type: "input_image",
-            image_url: `data:image/png;base64,${annotatedScreenshotBase64}`,
+            image_url: `data:image/png;base64,${imageBase64}`,
             detail: "high",
         });
     }

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

@@ -3,6 +3,7 @@ import { emitDesktopDebug, truncateForDebug } from "../../utils/desktop-debug.js
 import { getConfiguredStepDelayMs } from "../../utils/step-delay.js";
 import { buildActionEventMeta } from "../action-event-meta.js";
 import { buildMobileKeypressPayload, getAndroidAdbTransport, normalizeMobileKeypress } from "../mobile-keypress.js";
+import { actionForErrorLog, buildActionErrorOutput, buildDebugTextField, buildSensitiveDebugFields, buildTypeActionPayload, buildTypeActionText, isSensitiveAction, } from "../sensitive-action.js";
 import { resolveScrollGesture } from "../scroll-gesture.js";
 import { execAdb } from "./tools.js";
 function adbShell(deviceId, command) {
@@ -34,7 +35,8 @@ export async function handleModelAction(deviceId, action, scale = 1.0, context =
             y1,
             x2,
             y2,
-            text: typeof text === "string" ? truncateForDebug(text, 300) : undefined,
+            text: buildDebugTextField(action, truncateForDebug),
+            ...buildSensitiveDebugFields(action),
             keyCount: Array.isArray(keys) ? keys.length : 0,
             pathPoints: Array.isArray(path) ? path.length : 0
         });
@@ -79,7 +81,7 @@ export async function handleModelAction(deviceId, action, scale = 1.0, context =
                 }
                 break;
             case "type":
-                addOutput({ type: 'action', text: `Typing text: ${text}`, ...meta({ text }) });
+                addOutput({ type: 'action', text: buildTypeActionText(action, text), ...meta(buildTypeActionPayload(action, text)) });
                 const escapedText = text.replace(/(["\\$`])/g, "\\$1").replace(/ /g, "%s");
                 await adbShell(deviceId, `input text "${escapedText}"`);
                 break;
@@ -104,13 +106,15 @@ export async function handleModelAction(deviceId, action, scale = 1.0, context =
             default:
                 addOutput({ type: 'info', text: `Unknown action: ${JSON.stringify(action)}` });
         }
+        return { success: true };
     }
     catch (error) {
+        const outputError = buildActionErrorOutput(action, error);
         // Log full error details to file
         logger.error('Action execution error', {
-            action,
-            message: error.message,
-            stack: error.stack
+            action: actionForErrorLog(action),
+            message: outputError.message,
+            stack: isSensitiveAction(action) ? undefined : error.stack
         });
         emitDesktopDebug("device.error", "device", {
             runId: context?.runId,
@@ -121,12 +125,12 @@ export async function handleModelAction(deviceId, action, scale = 1.0, context =
             platform: "android",
             operation: "action.execute",
             actionType: action?.type,
-            message: error.message
+            message: outputError.message
         });
         // Show user-friendly error message
         addOutput({
             type: 'error',
-            text: `Error executing action: ${error.message}`,
+            text: outputError.text,
             eventType: 'error',
             actionType: action?.type,
             runId: context?.runId,
@@ -134,10 +138,11 @@ export async function handleModelAction(deviceId, action, scale = 1.0, context =
             instructionIndex: context?.instructionIndex,
             payload: {
                 eventId: context?.eventId,
-                message: error.message,
+                message: outputError.message,
                 platform: 'android'
             }
         });
         addOutput({ type: 'info', text: 'Full error details have been logged to the debug log.' });
+        return { success: false, error: outputError.message };
     }
 }