@loadmill/droid-cua 2.43.0 → 2.45.0

package/build/src/device/ios/node-cli-env.js

@@ -1,3 +1,5 @@
+import { accessSync, constants as fsConstants, readdirSync } from "fs";
+import os from "os";
 import path from "path";
 export const COMMON_NODE_BIN_DIRS = ["/opt/homebrew/bin", "/usr/local/bin", "/opt/local/bin"];
 function prependPathEntries(entries, originalPath) {
@@ -26,3 +28,56 @@ export function makeNodeCliCommandEnv(command) {
         PATH: prependPathEntries(binDirs, process.env.PATH)
     };
 }
+function parseNodeVersion(name) {
+    const match = /^v?(\d+)\.(\d+)\.(\d+)$/.exec(name);
+    return match ? match.slice(1).map(Number) : null;
+}
+function compareVersionsDescending(a, b) {
+    for (let i = 0; i < 3; i += 1) {
+        if (a[i] !== b[i])
+            return b[i] - a[i];
+    }
+    return 0;
+}
+function isExecutable(filePath) {
+    try {
+        accessSync(filePath, fsConstants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function listNvmNodeBinDirs(home = os.homedir()) {
+    if (!home)
+        return [];
+    const versionsDir = path.join(home, ".nvm", "versions", "node");
+    let names;
+    try {
+        names = readdirSync(versionsDir);
+    }
+    catch {
+        return [];
+    }
+    return names
+        .map((name) => ({ name, version: parseNodeVersion(name) }))
+        .filter((entry) => entry.version)
+        .sort((a, b) => compareVersionsDescending(a.version, b.version))
+        .map((entry) => path.join(versionsDir, entry.name, "bin"));
+}
+export function resolveNodeCliCommand(command, { pathEnv = process.env.PATH, commonDirs = COMMON_NODE_BIN_DIRS, home = os.homedir() } = {}) {
+    const pathDirs = pathEnv
+        ?.split(path.delimiter)
+        .map((dir) => dir.trim())
+        .filter(Boolean) ?? [];
+    for (const dir of new Set([...pathDirs, ...commonDirs])) {
+        const candidate = path.join(dir, command);
+        if (isExecutable(candidate))
+            return candidate;
+    }
+    const nvmBinDir = listNvmNodeBinDirs(home).find((dir) => isExecutable(path.join(dir, "node")));
+    if (nvmBinDir && isExecutable(path.join(nvmBinDir, command))) {
+        return path.join(nvmBinDir, command);
+    }
+    return command;
+}

package/build/src/device/ios/real-device/device-state.js

@@ -0,0 +1,40 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+const DEFAULT_DIR = path.join(os.homedir(), ".droid-cua", "ios-devices");
+function statePath(dir) {
+    return path.join(dir, "state.json");
+}
+async function readAll(dir) {
+    try {
+        return JSON.parse(await readFile(statePath(dir), "utf8")) || {};
+    }
+    catch {
+        return {};
+    }
+}
+function isPlainObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+export async function readDeviceState(udid, { dir = DEFAULT_DIR } = {}) {
+    const all = await readAll(dir);
+    return all[udid] ?? null;
+}
+export async function updateDeviceState(udid, patch, { dir = DEFAULT_DIR } = {}) {
+    const all = await readAll(dir);
+    const current = all[udid] ?? {};
+    const next = { ...current };
+    for (const [key, value] of Object.entries(patch)) {
+        next[key] = isPlainObject(value) && isPlainObject(current[key]) ? { ...current[key], ...value } : value;
+    }
+    all[udid] = next;
+    await mkdir(dir, { recursive: true });
+    const tempPath = `${statePath(dir)}.${process.pid}.${Date.now()}.tmp`;
+    await writeFile(tempPath, `${JSON.stringify(all, null, 2)}\n`, "utf8");
+    await rename(tempPath, statePath(dir));
+    return next;
+}
+export async function didIosVersionChange(udid, currentVersion, { dir = DEFAULT_DIR } = {}) {
+    const state = await readDeviceState(udid, { dir });
+    return Boolean(state?.lastIosVersion) && state.lastIosVersion !== currentVersion;
+}

package/build/src/device/ios/real-device/devicectl.js

@@ -0,0 +1,154 @@
+import { execFile } from "node:child_process";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+const DEFAULT_TIMEOUT_MS = 30_000;
+const INSTALL_TIMEOUT_MS = 180_000;
+let runner = execFileAsync;
+export class DevicectlError extends Error {
+    constructor({ kind, message, code = null, domain = null }) {
+        super(message);
+        this.name = "DevicectlError";
+        this.kind = kind;
+        this.code = code;
+        this.domain = domain;
+    }
+}
+export function __setDevicectlRunner(run = null) {
+    runner = run || execFileAsync;
+}
+function errorChain(error) {
+    const chain = [];
+    let current = error;
+    while (current && typeof current === "object" && chain.length < 10) {
+        chain.push(current);
+        const underlying = current.userInfo?.NSUnderlyingError;
+        current = underlying?.error ?? underlying;
+    }
+    return chain;
+}
+function describe(error) {
+    return error.userInfo?.NSLocalizedDescription?.string || "";
+}
+function classify(chain) {
+    const text = chain.map(describe).join("\n");
+    const hasCode = (domain, code) => chain.some((e) => e.domain === domain && e.code === code);
+    if (hasCode("com.apple.dt.CoreDeviceError", 10005) || /Developer Mode is disabled/i.test(text)) {
+        return "developer-mode-disabled";
+    }
+    if (/not been explicitly trusted/i.test(text))
+        return "untrusted-developer";
+    if (/is not installed/i.test(text))
+        return "app-not-installed";
+    if (/device (is|was) locked|could not be, unlocked/i.test(text))
+        return "device-locked";
+    if (/device was not found/i.test(text))
+        return "device-not-found";
+    if (/not paired|unpaired/i.test(text))
+        return "not-paired";
+    return "unknown";
+}
+export function devicectlErrorFromJson(error) {
+    const chain = errorChain(error);
+    const descriptions = [...new Set(chain.map(describe).filter(Boolean))];
+    return new DevicectlError({
+        kind: classify(chain),
+        message: descriptions.join(" ") || `devicectl failed (${error.domain} ${error.code})`,
+        code: error.code ?? null,
+        domain: error.domain ?? null,
+    });
+}
+async function readJson(file) {
+    try {
+        return JSON.parse(await readFile(file, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+async function runDevicectl(args, { timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
+    const dir = await mkdtemp(path.join(os.tmpdir(), "droid-cua-devicectl-"));
+    const jsonPath = path.join(dir, "output.json");
+    try {
+        let runError = null;
+        try {
+            await runner("xcrun", ["devicectl", ...args, "--json-output", jsonPath], { timeout: timeoutMs });
+        }
+        catch (err) {
+            runError = err;
+        }
+        if (runError?.killed || runError?.code === "ETIMEDOUT") {
+            throw new DevicectlError({
+                kind: "timeout",
+                message: `devicectl ${args.slice(0, 3).join(" ")} timed out after ${Math.round(timeoutMs / 1000)}s`,
+            });
+        }
+        const output = await readJson(jsonPath);
+        if (output?.info?.outcome === "failed" || output?.error) {
+            throw devicectlErrorFromJson(output.error || {});
+        }
+        if (!output || runError) {
+            const detail = runError?.stderr?.trim() || runError?.message || "no JSON output";
+            throw new DevicectlError({ kind: "unknown", message: `devicectl ${args.slice(0, 3).join(" ")} failed: ${detail}` });
+        }
+        return output.result ?? {};
+    }
+    finally {
+        await rm(dir, { recursive: true, force: true });
+    }
+}
+export async function listDevices() {
+    const result = await runDevicectl(["list", "devices"]);
+    return (result.devices || []).map((device) => ({
+        udid: device.hardwareProperties?.udid,
+        name: device.deviceProperties?.name,
+        model: device.hardwareProperties?.marketingName,
+        iosVersion: device.deviceProperties?.osVersionNumber,
+        pairingState: device.connectionProperties?.pairingState,
+        tunnelState: device.connectionProperties?.tunnelState,
+        transport: device.connectionProperties?.transportType,
+        developerModeStatus: device.deviceProperties?.developerModeStatus,
+        ddiServicesAvailable: device.deviceProperties?.ddiServicesAvailable === true,
+        identifier: device.identifier,
+    }));
+}
+export async function getLockState(udid) {
+    const result = await runDevicectl(["device", "info", "lockState", "--device", udid]);
+    return {
+        passcodeRequired: result.passcodeRequired === true,
+        unlockedSinceBoot: result.unlockedSinceBoot === true,
+    };
+}
+export async function getDdiServices(udid) {
+    const result = await runDevicectl(["device", "info", "ddiServices", "--device", udid]);
+    return result.ddiMetadata ?? null;
+}
+export async function listApps(udid, { includeAll = false } = {}) {
+    const args = ["device", "info", "apps", "--device", udid];
+    if (includeAll)
+        args.push("--include-all-apps");
+    const result = await runDevicectl(args);
+    return (result.apps || []).map((app) => ({
+        bundleIdentifier: app.bundleIdentifier,
+        name: app.name,
+        version: app.version,
+    }));
+}
+export async function listProcesses(udid) {
+    const result = await runDevicectl(["device", "info", "processes", "--device", udid]);
+    return (result.runningProcesses || []).map((proc) => ({
+        pid: proc.processIdentifier,
+        executable: proc.executable,
+    }));
+}
+export async function installApp(udid, appPath) {
+    const result = await runDevicectl(["device", "install", "app", "--device", udid, appPath], {
+        timeoutMs: INSTALL_TIMEOUT_MS,
+    });
+    return (result.installedApplications || []).map((app) => app.bundleID ?? app.bundleIdentifier);
+}
+export async function terminateProcess(udid, pid) {
+    await runDevicectl(["device", "process", "terminate", "--device", udid, "--pid", String(pid)]);
+}