@ceraph/react-native-mcp 0.2.1 → 0.3.1

package/dist/camera-image-writer.js

@@ -0,0 +1,280 @@
+import { readdir, rename, unlink, writeFile, mkdir, stat } from "node:fs/promises";
+import { isAbsolute, join, relative } from "node:path";
+import { syncCameraRegistry, relativeRegistryPath, } from "./camera-registry-sync.js";
+export const SUPPORTED_EXTENSIONS = [
+    "jpg",
+    "jpeg",
+    "png",
+    "webp",
+    "heic",
+];
+const CAMERA_IMAGES_SUBPATH = join(".ceraph", "camera-images");
+export const MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+const IMAGE_KEY_REGEX = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const SUBDIR_REGEX = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+export class AddCameraImageError extends Error {
+    code;
+    remediation;
+    constructor(code, message, remediation) {
+        super(message);
+        this.name = "AddCameraImageError";
+        this.code = code;
+        this.remediation = remediation;
+    }
+}
+export function validateImageKey(key) {
+    if (typeof key !== "string" || key.length === 0) {
+        throw new AddCameraImageError("invalid-image-key", "imageKey is required.", "Pass a non-empty `imageKey` like `\"profile\"` or `\"handwriting-sample-1\"`.");
+    }
+    if (key.length > 64) {
+        throw new AddCameraImageError("invalid-image-key", `imageKey '${key}' is longer than 64 characters.`, "Keep imageKey short and descriptive (lowercase, hyphen-separated).");
+    }
+    if (!IMAGE_KEY_REGEX.test(key)) {
+        throw new AddCameraImageError("invalid-image-key", `imageKey '${key}' must be lowercase letters/digits separated by single hyphens.`, "Use only [a-z0-9-], no leading/trailing/consecutive hyphens, no spaces, " +
+            "no uppercase. Example: `handwriting-sample-1`.");
+    }
+}
+export function validateSubDir(subDir) {
+    if (typeof subDir !== "string" || subDir.length === 0) {
+        throw new AddCameraImageError("invalid-subdir", "subDir was provided but is empty.", "Either omit `subDir` or pass a single safe path segment " +
+            "(lowercase, hyphen-separated, no slashes).");
+    }
+    if (subDir.length > 64) {
+        throw new AddCameraImageError("invalid-subdir", `subDir '${subDir}' is longer than 64 characters.`, "Use a short, single-segment subdirectory name.");
+    }
+    if (!SUBDIR_REGEX.test(subDir)) {
+        throw new AddCameraImageError("invalid-subdir", `subDir '${subDir}' must be a single lowercase segment.`, "Use only [a-z0-9-], no slashes, no `..`, no leading `/`. " +
+            "Example: `id-documents`.");
+    }
+}
+export function detectImageType(bytes) {
+    if (bytes.length < 12)
+        return null;
+    if (bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff) {
+        return { ext: "jpg", mime: "image/jpeg" };
+    }
+    if (bytes[0] === 0x89 &&
+        bytes[1] === 0x50 &&
+        bytes[2] === 0x4e &&
+        bytes[3] === 0x47 &&
+        bytes[4] === 0x0d &&
+        bytes[5] === 0x0a &&
+        bytes[6] === 0x1a &&
+        bytes[7] === 0x0a) {
+        return { ext: "png", mime: "image/png" };
+    }
+    if (bytes[0] === 0x52 &&
+        bytes[1] === 0x49 &&
+        bytes[2] === 0x46 &&
+        bytes[3] === 0x46 &&
+        bytes[8] === 0x57 &&
+        bytes[9] === 0x45 &&
+        bytes[10] === 0x42 &&
+        bytes[11] === 0x50) {
+        return { ext: "webp", mime: "image/webp" };
+    }
+    if (bytes[4] === 0x66 &&
+        bytes[5] === 0x74 &&
+        bytes[6] === 0x79 &&
+        bytes[7] === 0x70) {
+        const brand = String.fromCharCode(bytes[8] ?? 0, bytes[9] ?? 0, bytes[10] ?? 0, bytes[11] ?? 0);
+        const HEIF_BRANDS = new Set([
+            "heic",
+            "heix",
+            "hevc",
+            "hevx",
+            "heim",
+            "heis",
+            "mif1",
+            "msf1",
+        ]);
+        if (HEIF_BRANDS.has(brand)) {
+            return { ext: "heic", mime: "image/heic" };
+        }
+    }
+    return null;
+}
+export function normalizeContentTypeHint(hint) {
+    if (!hint || typeof hint !== "string")
+        return null;
+    const lower = hint.trim().toLowerCase();
+    if (lower.length === 0)
+        return null;
+    let tail = lower;
+    if (tail.startsWith("image/"))
+        tail = tail.slice("image/".length);
+    if (tail.startsWith("."))
+        tail = tail.slice(1);
+    const semi = tail.indexOf(";");
+    if (semi >= 0)
+        tail = tail.slice(0, semi).trim();
+    if (tail === "jpeg" || tail === "jpg")
+        return "jpg";
+    if (tail === "png")
+        return "png";
+    if (tail === "webp")
+        return "webp";
+    if (tail === "heic" || tail === "heif")
+        return "heic";
+    return null;
+}
+async function findExistingForKey(dir, imageKey) {
+    let entries;
+    try {
+        const s = await stat(dir);
+        if (!s.isDirectory())
+            return null;
+        entries = await readdir(dir);
+    }
+    catch {
+        return null;
+    }
+    const lowerKey = imageKey.toLowerCase();
+    for (const name of entries) {
+        const dot = name.lastIndexOf(".");
+        if (dot <= 0)
+            continue;
+        const stem = name.slice(0, dot);
+        if (stem.toLowerCase() !== lowerKey)
+            continue;
+        const extWithDot = name.slice(dot).toLowerCase();
+        const ext = extWithDot.startsWith(".") ? extWithDot.slice(1) : extWithDot;
+        if (!SUPPORTED_EXTENSIONS.includes(ext))
+            continue;
+        return {
+            absolutePath: join(dir, name),
+            ext: ext,
+        };
+    }
+    return null;
+}
+export async function addCameraImage(projectDir, options, deps = {}) {
+    const { imageKey, imageBase64, contentType, overwrite, subDir } = options;
+    const sync = deps.syncCameraRegistry ?? syncCameraRegistry;
+    validateImageKey(imageKey);
+    if (subDir !== undefined && subDir !== "") {
+        validateSubDir(subDir);
+    }
+    if (typeof imageBase64 !== "string" || imageBase64.length === 0) {
+        throw new AddCameraImageError("invalid-base64", "imageBase64 is required and must be a non-empty string.", "Pass the base64-encoded image bytes (without a `data:` prefix).");
+    }
+    const rawBase64 = imageBase64.startsWith("data:")
+        ? imageBase64.slice(imageBase64.indexOf(",") + 1)
+        : imageBase64;
+    const MAX_BASE64_CHARS = Math.ceil((MAX_IMAGE_BYTES * 4) / 3) + 32;
+    if (rawBase64.length > MAX_BASE64_CHARS) {
+        const approxMb = ((rawBase64.length * 3) / 4 / (1024 * 1024)).toFixed(2);
+        throw new AddCameraImageError("image-too-large", `Encoded payload is ~${approxMb} MB which exceeds the 5 MB cap.`, "Resize or recompress the image before uploading. Test fixtures " +
+            "rarely need to be larger than 1 MB. Cap: 5 MB.");
+    }
+    const bytes = Buffer.from(rawBase64, "base64");
+    if (bytes.length === 0) {
+        throw new AddCameraImageError("invalid-base64", "imageBase64 decoded to zero bytes.", "Verify the base64 string is intact and not a placeholder.");
+    }
+    if (bytes.length > MAX_IMAGE_BYTES) {
+        const mb = (bytes.length / (1024 * 1024)).toFixed(2);
+        throw new AddCameraImageError("image-too-large", `Image is ${mb} MB which exceeds the 5 MB cap.`, "Resize or recompress the image before uploading. Test fixtures " +
+            "rarely need to be larger than 1 MB — over-large fixtures inflate " +
+            "the repo and slow Metro bundling. Cap: 5 MB.");
+    }
+    const detected = detectImageType(new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength));
+    if (!detected) {
+        throw new AddCameraImageError("unsupported-image-format", "Could not detect a supported image format from the decoded bytes.", "Supported formats: JPEG, PNG, WebP, HEIC. " +
+            "Re-export the image in one of these and try again.");
+    }
+    const warnings = [];
+    if (contentType !== undefined && contentType !== "") {
+        const hinted = normalizeContentTypeHint(contentType);
+        if (hinted === null) {
+            warnings.push({
+                code: "content-type-unrecognized",
+                message: `contentType '${contentType}' is not a recognized image MIME type; ` +
+                    `using detected '${detected.mime}' instead.`,
+            });
+        }
+        else if (hinted !== detected.ext) {
+            warnings.push({
+                code: "content-type-mismatch",
+                message: `Declared contentType '${contentType}' does not match detected ` +
+                    `'${detected.mime}' — trusting the bytes.`,
+            });
+        }
+    }
+    if (bytes.length > 1 * 1024 * 1024) {
+        const mb = (bytes.length / (1024 * 1024)).toFixed(2);
+        warnings.push({
+            code: "image-larger-than-typical",
+            message: `Image is ${mb} MB. Test fixtures typically fit under 1 MB; ` +
+                `consider downsampling if it's larger than the camera screen needs.`,
+        });
+    }
+    const baseDir = join(projectDir, CAMERA_IMAGES_SUBPATH);
+    const targetDir = subDir !== undefined && subDir !== "" ? join(baseDir, subDir) : baseDir;
+    const rel = relative(baseDir, targetDir);
+    if (rel.startsWith("..") || isAbsolute(rel) || rel.includes("\0")) {
+        throw new AddCameraImageError("path-traversal", `Resolved subDir escapes .ceraph/camera-images/: ${targetDir}`, "Pass a single safe segment for subDir (lowercase, hyphens, " +
+            "no slashes, no `..`).");
+    }
+    const targetExt = detected.ext;
+    const targetFile = join(targetDir, `${imageKey}.${targetExt}`);
+    const existing = await findExistingForKey(targetDir, imageKey);
+    let removedSiblingPath;
+    let replaced = false;
+    if (existing) {
+        if (!overwrite) {
+            const relExisting = relative(projectDir, existing.absolutePath);
+            throw new AddCameraImageError("collision", `The imageKey '${imageKey}' already maps to ${relExisting}.`, `Pass \`overwrite: true\` to replace it, or pick a different imageKey.`);
+        }
+        replaced = true;
+    }
+    await mkdir(targetDir, { recursive: true });
+    if (existing &&
+        existing.ext === targetExt &&
+        existing.absolutePath !== targetFile &&
+        existing.absolutePath.toLowerCase() === targetFile.toLowerCase()) {
+        try {
+            await rename(existing.absolutePath, targetFile);
+        }
+        catch (err) {
+            void err;
+        }
+    }
+    await writeFile(targetFile, bytes);
+    if (existing) {
+        const oldPath = existing.absolutePath;
+        const newPath = targetFile;
+        const samePathInsensitive = oldPath.toLowerCase() === newPath.toLowerCase();
+        const extChanged = existing.ext !== targetExt;
+        const stemCaseChanged = !samePathInsensitive && oldPath !== newPath;
+        if (!samePathInsensitive && (extChanged || stemCaseChanged)) {
+            try {
+                await unlink(oldPath);
+                removedSiblingPath = relative(projectDir, oldPath);
+            }
+            catch (err) {
+                throw new AddCameraImageError("unlink-failed", `New image was written but failed to remove stale ${relative(projectDir, oldPath)}: ` +
+                    `${err instanceof Error ? err.message : String(err)}`, "Remove the stale file manually so the imageKey is not backed by two files.");
+            }
+        }
+    }
+    let syncResult;
+    try {
+        syncResult = await sync(projectDir);
+    }
+    catch (err) {
+        throw new AddCameraImageError("registry-sync-failed", `Image was written but registry sync failed: ${err instanceof Error ? err.message : String(err)}`, "Re-run `rn_sync_camera_registry` manually to regenerate `_registry.ts`. " +
+            "The image file itself is on disk and safe.");
+    }
+    return {
+        written: relative(projectDir, targetFile),
+        registry: relativeRegistryPath(projectDir, syncResult.registryPath),
+        registered: syncResult.registered.map((r) => r.key),
+        detectedContentType: detected.mime,
+        detectedExt: detected.ext,
+        replaced,
+        removedSiblingPath,
+        bytes: bytes.length,
+        warnings,
+        registryState: syncResult.writtenOrUnchanged,
+    };
+}

package/dist/camera-registry-sync.d.ts

@@ -0,0 +1,18 @@
+declare const SUPPORTED_EXTENSIONS: readonly [".jpg", ".jpeg", ".png", ".webp", ".heic"];
+type SupportedExt = (typeof SUPPORTED_EXTENSIONS)[number];
+declare const REGISTRY_BASENAME = "_registry.ts";
+declare const CAMERA_IMAGES_SUBPATH: string;
+export interface RegisteredImage {
+    key: string;
+    relativePath: string;
+    ext: SupportedExt;
+}
+export interface SyncResult {
+    registered: RegisteredImage[];
+    registryPath: string;
+    writtenOrUnchanged: "written" | "unchanged" | "missing-dir";
+}
+export declare function buildRegistrySource(images: RegisteredImage[]): string;
+export declare function syncCameraRegistry(projectDir: string): Promise<SyncResult>;
+export declare function relativeRegistryPath(projectDir: string, registryPath: string): string;
+export { CAMERA_IMAGES_SUBPATH, REGISTRY_BASENAME };

package/dist/camera-registry-sync.js

@@ -0,0 +1,117 @@
+import { readdir, readFile, writeFile, mkdir, stat } from "node:fs/promises";
+import { join, relative } from "node:path";
+const SUPPORTED_EXTENSIONS = [
+    ".jpg",
+    ".jpeg",
+    ".png",
+    ".webp",
+    ".heic",
+];
+const REGISTRY_BASENAME = "_registry.ts";
+const CAMERA_IMAGES_SUBPATH = join(".ceraph", "camera-images");
+function isSupportedExt(ext) {
+    return SUPPORTED_EXTENSIONS.includes(ext);
+}
+function extPriority(ext) {
+    return SUPPORTED_EXTENSIONS.indexOf(ext);
+}
+function splitImageName(name) {
+    const dot = name.lastIndexOf(".");
+    if (dot <= 0)
+        return null;
+    const stem = name.slice(0, dot);
+    const ext = name.slice(dot).toLowerCase();
+    if (!isSupportedExt(ext))
+        return null;
+    if (stem.length === 0)
+        return null;
+    return { stem, ext };
+}
+export function buildRegistrySource(images) {
+    const header = "// AUTO-GENERATED by @ceraph/react-native-mcp — do not edit by hand.\n" +
+        "// Re-run `rn_sync_camera_registry` after adding or removing images.\n" +
+        'import { configureTestImage } from "@ceraph/react-native-mcp/shim";\n' +
+        "\n" +
+        "export function applyCameraImageRegistry(): void {\n";
+    if (images.length === 0) {
+        return (header +
+            "  // No images registered yet. Drop files into .ceraph/camera-images/\n" +
+            "  // and re-run `rn_sync_camera_registry`.\n" +
+            "}\n");
+    }
+    const keyColumn = Math.max(...images.map((i) => i.key.length + 2));
+    const lines = images.map((img) => {
+        const keyLiteral = `"${img.key}",`;
+        const padded = keyLiteral.padEnd(keyColumn + 1, " ");
+        return `  configureTestImage(${padded} require("${img.relativePath}"));`;
+    });
+    return header + lines.join("\n") + "\n}\n";
+}
+export async function syncCameraRegistry(projectDir) {
+    const dir = join(projectDir, CAMERA_IMAGES_SUBPATH);
+    const registryPath = join(dir, REGISTRY_BASENAME);
+    let entries;
+    try {
+        const s = await stat(dir);
+        if (!s.isDirectory()) {
+            return {
+                registered: [],
+                registryPath,
+                writtenOrUnchanged: "missing-dir",
+            };
+        }
+        entries = await readdir(dir);
+    }
+    catch {
+        return {
+            registered: [],
+            registryPath,
+            writtenOrUnchanged: "missing-dir",
+        };
+    }
+    const byStem = new Map();
+    for (const name of entries) {
+        if (name === REGISTRY_BASENAME)
+            continue;
+        if (name.startsWith("_") || name.startsWith("."))
+            continue;
+        if (name === "README.md")
+            continue;
+        const split = splitImageName(name);
+        if (!split)
+            continue;
+        const candidate = {
+            key: split.stem,
+            relativePath: `./${name}`,
+            ext: split.ext,
+        };
+        const existing = byStem.get(split.stem);
+        if (!existing) {
+            byStem.set(split.stem, candidate);
+            continue;
+        }
+        if (extPriority(candidate.ext) < extPriority(existing.ext)) {
+            byStem.set(split.stem, candidate);
+        }
+    }
+    const registered = Array.from(byStem.values()).sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+    const nextSource = buildRegistrySource(registered);
+    let current = null;
+    try {
+        current = await readFile(registryPath, "utf-8");
+    }
+    catch {
+        current = null;
+    }
+    if (current === nextSource) {
+        return { registered, registryPath, writtenOrUnchanged: "unchanged" };
+    }
+    await mkdir(dir, { recursive: true });
+    await writeFile(registryPath, nextSource, "utf-8");
+    return { registered, registryPath, writtenOrUnchanged: "written" };
+}
+export function relativeRegistryPath(projectDir, registryPath) {
+    const rel = relative(projectDir, registryPath);
+    return rel.length > 0 ? rel : registryPath;
+}
+export { CAMERA_IMAGES_SUBPATH, REGISTRY_BASENAME };

package/dist/cli.d.ts

@@ -1,9 +1,2 @@
 #!/usr/bin/env node
-/**
- * @ceraph/react-native-mcp CLI entry point.
- *
- * Usage:
- *   npx @ceraph/react-native-mcp init   — set up MCP config and error hook
- *   npx @ceraph/react-native-mcp        — start the MCP server (stdio transport)
- */
 export {};

package/dist/cli.js

@@ -1,14 +1,46 @@
 #!/usr/bin/env node
-/**
- * @ceraph/react-native-mcp CLI entry point.
- *
- * Usage:
- *   npx @ceraph/react-native-mcp init   — set up MCP config and error hook
- *   npx @ceraph/react-native-mcp        — start the MCP server (stdio transport)
- */
-const command = process.argv[2];
+const argv = process.argv.slice(2);
+const command = argv[0];
+const flags = new Set(argv.slice(1));
+const HELP_TEXT = `@ceraph/react-native-mcp
+
+USAGE
+  npx @ceraph/react-native-mcp <command> [flags]
+
+COMMANDS
+  init                  Wire up MCP clients, hooks, AST replacements, and preflight.
+  uninstall             Reverse the mutations init applied.
+  (no command)          Start the MCP server over stdio.
+
+FLAGS
+  --agent               Pass when an AI tool is driving the install — defers
+                        interactive camera setup to the agent via a single
+                        CERAPH_INIT_AGENT_HINT={...} JSON line emitted on
+                        stdout at completion. Equivalent to CERAPH_AGENT_MODE=1.
+  --help, -h            Show this help text.
+`;
+if (command === "--help" || command === "-h" || command === "help") {
+    process.stdout.write(HELP_TEXT);
+    process.exit(0);
+}
 if (command === "init") {
-    await import("./init.js");
+    const agentMode = flags.has("--agent") || process.env.CERAPH_AGENT_MODE === "1";
+    const { runInit } = await import("./init.js");
+    await runInit({ agentMode }).catch((err) => {
+        console.error("Init failed:", err);
+        process.exit(1);
+    });
+}
+else if (command === "uninstall") {
+    const { runUninstallCli } = await import("./uninstall/cli-runner.js");
+    try {
+        const res = await runUninstallCli({ argv: process.argv.slice(3) });
+        process.exit(res.exitCode);
+    }
+    catch (err) {
+        console.error("Uninstall failed:", err);
+        process.exit(1);
+    }
 }
 else {
     await import("./index.js");

package/dist/device-autonomy.d.ts

@@ -0,0 +1,30 @@
+import type { ScreenManager } from "./screen.js";
+export type LockState = "unlocked" | "locked" | "screen-off" | "unknown";
+export interface AwakeResult {
+    awake: boolean;
+    lockState: LockState;
+    remediation?: string;
+    details?: Record<string, unknown>;
+}
+export interface HeartbeatHandle {
+    stop: () => void;
+    intervalMs: number;
+}
+export declare class DeviceAutonomy {
+    private screen;
+    constructor(screen: ScreenManager);
+    ensureAwake(): Promise<AwakeResult>;
+    keepAliveHeartbeat(opts?: {
+        intervalMs?: number;
+    }): HeartbeatHandle;
+    getLockState(): Promise<LockState>;
+    private hasCoverSheet;
+    setOrientation(orientation: "portrait" | "landscape"): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    disableAutoLock(): {
+        success: false;
+        message: string;
+    };
+}

package/dist/device-autonomy.js

@@ -0,0 +1,117 @@
+export class DeviceAutonomy {
+    screen;
+    constructor(screen) {
+        this.screen = screen;
+    }
+    async ensureAwake() {
+        const reachable = await this.screen.isAvailable();
+        if (!reachable) {
+            return {
+                awake: false,
+                lockState: "unknown",
+                remediation: "WebDriverAgent is not reachable at localhost:8100. " +
+                    "Start WDA on your device (Xcode → WebDriverAgentRunner) and try again.",
+            };
+        }
+        const state = await this.getLockState();
+        if (state === "unlocked") {
+            return { awake: true, lockState: "unlocked" };
+        }
+        if (state === "locked" || state === "screen-off") {
+            const unlock = await this.screen.unlock();
+            if (unlock.success) {
+                const after = await this.getLockState();
+                if (after === "unlocked") {
+                    return { awake: true, lockState: "unlocked" };
+                }
+            }
+            await this.screen.pressKey("home").catch(() => undefined);
+            const after = await this.getLockState();
+            if (after === "unlocked") {
+                return { awake: true, lockState: "unlocked" };
+            }
+            return {
+                awake: false,
+                lockState: after,
+                remediation: "Device is locked. Unlock it manually once, then set " +
+                    "Settings → Display & Brightness → Auto-Lock → Never so it " +
+                    "stays awake while flows run. WDA can't bypass Face ID or a passcode.",
+            };
+        }
+        return {
+            awake: false,
+            lockState: state,
+            remediation: "Unable to determine device lock state. Make sure the device is " +
+                "unlocked and the screen is on, then re-run the flow.",
+        };
+    }
+    keepAliveHeartbeat(opts = {}) {
+        const intervalMs = opts.intervalMs ?? 1500;
+        const timer = setInterval(() => {
+            this.screen.pingStatus().catch(() => undefined);
+        }, intervalMs);
+        if (typeof timer.unref === "function")
+            timer.unref();
+        let stopped = false;
+        return {
+            intervalMs,
+            stop: () => {
+                if (stopped)
+                    return;
+                stopped = true;
+                clearInterval(timer);
+            },
+        };
+    }
+    async getLockState() {
+        const locked = await this.screen.isLocked();
+        if (locked === true)
+            return "locked";
+        if (locked === false) {
+            const cover = await this.hasCoverSheet();
+            return cover ? "locked" : "unlocked";
+        }
+        const cover = await this.hasCoverSheet();
+        if (cover === null)
+            return "unknown";
+        return cover ? "locked" : "unlocked";
+    }
+    async hasCoverSheet() {
+        const src = await this.screen.getSource();
+        if (!src.success || !src.source)
+            return null;
+        const needles = ["sbcoversheet", "lock screen", "lockscreen"];
+        let found = false;
+        const visit = (e) => {
+            if (found)
+                return;
+            const haystack = [e.name, e.label, e.type]
+                .filter(Boolean)
+                .join(" ")
+                .toLowerCase();
+            if (needles.some((n) => haystack.includes(n))) {
+                found = true;
+                return;
+            }
+            const children = e.children;
+            if (Array.isArray(children)) {
+                for (const c of children)
+                    visit(c);
+            }
+        };
+        visit(src.source);
+        return found;
+    }
+    async setOrientation(orientation) {
+        return this.screen.setOrientation(orientation);
+    }
+    disableAutoLock() {
+        return {
+            success: false,
+            message: "iOS does not expose an API for disabling Auto-Lock. Open " +
+                "Settings → Display & Brightness → Auto-Lock → Never on the device " +
+                "before running long flows. The flow runner keeps WDA's session " +
+                "warm with a heartbeat, but it cannot prevent Auto-Lock by itself.",
+        };
+    }
+}