@loadmill/droid-cua 2.16.0 → 2.18.0

package/build/src/core/scenario-planner.js

@@ -0,0 +1,85 @@
+import { resolveEffectiveHelperModel } from "./runtime-config.js";
+import { buildScenarioPlannerMessages } from "../prompts/scenario-planner.js";
+function parseScenarioPlannerContent(content) {
+    try {
+        return JSON.parse(content);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Invalid JSON.";
+        throw new Error(`Could not parse scenario planner response: ${message}`);
+    }
+}
+function normalizeCaseName(value, fallback) {
+    const trimmed = typeof value === "string" ? value.trim() : "";
+    return trimmed || fallback;
+}
+function dedupeCaseNames(cases) {
+    const usedNames = new Set();
+    const baseCounts = new Map();
+    return cases.map((entry) => {
+        const baseName = entry.caseName;
+        let nextIndex = baseCounts.get(baseName) || 1;
+        let caseName = baseName;
+        while (usedNames.has(caseName)) {
+            nextIndex += 1;
+            caseName = `${baseName} (${nextIndex})`;
+        }
+        baseCounts.set(baseName, nextIndex);
+        usedNames.add(caseName);
+        return {
+            ...entry,
+            caseName,
+        };
+    });
+}
+export function validateScenarioCases(rawCases, candidateTests) {
+    if (!Array.isArray(rawCases) || rawCases.length === 0) {
+        throw new Error("Scenario planner did not return any cases.");
+    }
+    const candidateNames = new Set(candidateTests.map((test) => test.testName));
+    const normalizedCases = rawCases.map((rawCase, index) => {
+        if (!rawCase || typeof rawCase !== "object" || Array.isArray(rawCase)) {
+            throw new Error(`Scenario case ${index + 1} must be an object.`);
+        }
+        const testName = typeof rawCase.testName === "string" ? rawCase.testName.trim() : "";
+        if (!candidateNames.has(testName)) {
+            throw new Error(`Scenario case ${index + 1} references unknown test "${testName || "(missing)"}".`);
+        }
+        const caseName = normalizeCaseName(rawCase.caseName, `${testName} / Case ${index + 1}`);
+        const testDataContext = typeof rawCase.testDataContext === "string" ? rawCase.testDataContext.trim() : "";
+        return {
+            testName,
+            caseName,
+            testDataContext,
+        };
+    });
+    return dedupeCaseNames(normalizedCases);
+}
+export async function planScenarioRuns({ client, runtimeConfig, scenarioPrompt, tests, appContextText = "", testDataText = "", }) {
+    if (!client?.chat?.completions?.create) {
+        throw new Error("Scenario planning requires an LLM client.");
+    }
+    const prompt = typeof scenarioPrompt === "string" ? scenarioPrompt.trim() : "";
+    if (!prompt) {
+        throw new Error("--scenario must be a non-empty string.");
+    }
+    if (!Array.isArray(tests) || tests.length === 0) {
+        throw new Error("Scenario planning requires at least one candidate test.");
+    }
+    const response = await client.chat.completions.create({
+        model: resolveEffectiveHelperModel({
+            llmProviderMode: runtimeConfig?.llmProviderMode,
+            cuaModel: runtimeConfig?.cuaModel,
+        }),
+        messages: buildScenarioPlannerMessages({
+            scenarioPrompt: prompt,
+            tests,
+            appContextText,
+            testDataText,
+        }),
+        response_format: { type: "json_object" },
+    });
+    const content = response.choices?.[0]?.message?.content || "{}";
+    const parsed = parseScenarioPlannerContent(content);
+    return validateScenarioCases(parsed.cases, tests);
+}

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/test-data-import.js

@@ -0,0 +1,62 @@
+import path from "path";
+import { resolveEffectiveHelperModel } from "./runtime-config.js";
+import { buildTestDataImportMessages } from "../prompts/test-data-import.js";
+export const TEST_DATA_IMPORT_EXTENSIONS = [".csv", ".txt"];
+export function isSupportedTestDataImportPath(filePath) {
+    return TEST_DATA_IMPORT_EXTENSIONS.includes(path.extname(String(filePath ?? "")).toLowerCase());
+}
+export function assertSupportedTestDataImportPath(filePath) {
+    if (!isSupportedTestDataImportPath(filePath)) {
+        throw new Error("Test data import supports CSV and TXT files only.");
+    }
+}
+function parseTestDataImportContent(content) {
+    try {
+        return JSON.parse(content);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Invalid JSON.";
+        throw new Error(`Could not parse test data import response: ${message}`);
+    }
+}
+function normalizeGeneratedContent(value) {
+    const content = typeof value === "string" ? value.trim() : "";
+    if (!content) {
+        throw new Error("Test data import returned empty content.");
+    }
+    if (/^```/.test(content)) {
+        throw new Error("Test data import returned code-fenced content instead of markdown.");
+    }
+    return content.endsWith("\n") ? content : `${content}\n`;
+}
+export async function importTestDataMarkdown({ client, runtimeConfig, currentContent = "", importedFileName, importedFileText, instructions = "", }) {
+    if (!client?.chat?.completions?.create) {
+        throw new Error("Test data import requires an LLM client.");
+    }
+    const fileName = typeof importedFileName === "string" ? importedFileName.trim() : "";
+    if (!fileName) {
+        throw new Error("Imported file name is required.");
+    }
+    const fileText = typeof importedFileText === "string" ? importedFileText : "";
+    if (!fileText.trim()) {
+        throw new Error("Selected import file is empty.");
+    }
+    const response = await client.chat.completions.create({
+        model: resolveEffectiveHelperModel({
+            llmProviderMode: runtimeConfig?.llmProviderMode,
+            cuaModel: runtimeConfig?.cuaModel,
+        }),
+        messages: buildTestDataImportMessages({
+            currentContent,
+            importedFileName: fileName,
+            importedFileText: fileText,
+            instructions,
+        }),
+        response_format: { type: "json_object" },
+    });
+    const content = response.choices?.[0]?.message?.content || "{}";
+    const parsed = parseTestDataImportContent(content);
+    return {
+        content: normalizeGeneratedContent(parsed.content),
+    };
+}

package/build/src/core/test-data.js

@@ -0,0 +1,103 @@
+import path from "path";
+import { access, readFile } from "fs/promises";
+import { constants as fsConstants } from "fs";
+export const TEST_DATA_FILENAME = "test-data.md";
+export const DEFAULT_TEST_DATA_TEMPLATE = `# Test Data
+<!-- Concrete data the agent can use during Scenario Runs. Keep entries named and specific. -->
+<!-- Examples below are commented out so they are guidance, not usable test data. -->
+
+## Accounts
+<!--
+### Standard buyer
+Email:
+Password:
+Notes: When should the agent use this account?
+-->
+
+## Products
+<!--
+### In-stock product
+Name:
+SKU:
+Notes:
+-->
+
+## Payment Methods
+<!--
+### Valid card
+Number:
+Expiration:
+CVV:
+Notes:
+-->
+
+## Roles and Permissions
+
+## Regions and Locales
+
+## Other Data
+`;
+export function getDefaultProjectTestDataPath(projectPath) {
+    return path.join(projectPath, TEST_DATA_FILENAME);
+}
+export function normalizeTestDataTemplateText(text) {
+    return String(text ?? "").replace(/\r\n?/g, "\n").replace(/[ \t]+$/gm, "").trimEnd();
+}
+export function isDefaultTestDataTemplate(text) {
+    if (!String(text ?? "").trim()) {
+        return true;
+    }
+    return normalizeTestDataTemplateText(text) === normalizeTestDataTemplateText(DEFAULT_TEST_DATA_TEMPLATE);
+}
+export async function readTestDataFile(filePath) {
+    await access(filePath, fsConstants.R_OK);
+    return await readFile(filePath, "utf-8");
+}
+export async function loadTestData({ testDataPath }) {
+    if (!testDataPath) {
+        return { text: "", testDataPath: null };
+    }
+    const text = await readTestDataFile(testDataPath);
+    return { text, testDataPath };
+}
+/**
+ * @param {{
+ *   testDataPath?: string | null,
+ *   missingFileStatus?: string | null,
+ * }} [options]
+ */
+export async function resolveExecutionTestData({ testDataPath = null, missingFileStatus = null, } = {}) {
+    if (!testDataPath) {
+        return {
+            status: "omitted",
+            text: "",
+            testDataPath: null,
+            message: null,
+        };
+    }
+    try {
+        const result = await loadTestData({ testDataPath });
+        return {
+            status: result.text.trim().length > 0 ? "loaded" : "empty",
+            text: result.text,
+            testDataPath: result.testDataPath,
+            message: null,
+        };
+    }
+    catch (error) {
+        if (missingFileStatus && error && typeof error === "object" && error.code === "ENOENT") {
+            return {
+                status: missingFileStatus,
+                text: "",
+                testDataPath,
+                message: null,
+            };
+        }
+        return {
+            status: "failed",
+            text: "",
+            testDataPath,
+            message: error instanceof Error ? error.message : "Unknown test data error",
+        };
+    }
+}

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 };
     }
 }