@ceraph/react-native-mcp 0.2.2 → 0.3.2

package/dist/app-lifecycle.js

@@ -0,0 +1,487 @@
+import { spawn } from "node:child_process";
+function runCommand(cmd, args, opts = {}) {
+    return new Promise((resolve) => {
+        let stdout = "";
+        let stderr = "";
+        let child;
+        try {
+            child = spawn(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
+        }
+        catch (err) {
+            resolve({
+                code: 127,
+                stdout: "",
+                stderr: err instanceof Error ? err.message : String(err),
+            });
+            return;
+        }
+        const timer = setTimeout(() => {
+            try {
+                child.kill("SIGKILL");
+            }
+            catch {
+            }
+        }, opts.timeoutMs ?? 15000);
+        child.stdout?.on("data", (d) => {
+            stdout += d.toString();
+        });
+        child.stderr?.on("data", (d) => {
+            stderr += d.toString();
+        });
+        let settled = false;
+        child.on("error", (err) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve({
+                code: 127,
+                stdout,
+                stderr: stderr + (err.message ?? String(err)),
+            });
+        });
+        child.on("exit", (code) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve({ code: code ?? 1, stdout, stderr });
+        });
+    });
+}
+async function hasBinary(bin) {
+    const res = await runCommand("which", [bin], { timeoutMs: 2000 });
+    return res.code === 0 && res.stdout.trim().length > 0;
+}
+export function parseSimctlListapps(stdout) {
+    const apps = [];
+    let depth = 0;
+    let inApp = false;
+    let appKey = null;
+    let bundleId = null;
+    let name = null;
+    let displayName = null;
+    let shortVersion = null;
+    let version = null;
+    const stripValue = (raw) => {
+        let s = raw.trim();
+        if (s.endsWith(";"))
+            s = s.slice(0, -1).trim();
+        if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'"))) {
+            s = s.slice(1, -1);
+        }
+        return s;
+    };
+    for (const rawLine of stdout.split("\n")) {
+        const line = rawLine.trim();
+        if (line.length === 0)
+            continue;
+        if (depth === 1 && !inApp && line.endsWith("{")) {
+            const eqIdx = line.indexOf("=");
+            if (eqIdx > 0) {
+                const key = stripValue(line.slice(0, eqIdx));
+                appKey = key;
+                bundleId = key;
+                name = null;
+                displayName = null;
+                shortVersion = null;
+                version = null;
+                inApp = true;
+            }
+            depth += 1;
+            continue;
+        }
+        if (line.endsWith("{")) {
+            depth += 1;
+            continue;
+        }
+        if (line === "};" || line === "}") {
+            if (inApp && depth === 2) {
+                const finalBundleId = bundleId ?? appKey;
+                if (finalBundleId) {
+                    apps.push({
+                        bundleId: finalBundleId,
+                        name: displayName ?? name ?? finalBundleId,
+                        version: shortVersion ?? version ?? undefined,
+                    });
+                }
+                inApp = false;
+                appKey = null;
+                bundleId = null;
+                name = null;
+                displayName = null;
+                shortVersion = null;
+                version = null;
+            }
+            depth = Math.max(0, depth - 1);
+            continue;
+        }
+        if (inApp && depth === 2) {
+            const eqIdx = line.indexOf("=");
+            if (eqIdx < 0)
+                continue;
+            const key = line.slice(0, eqIdx).trim();
+            const value = stripValue(line.slice(eqIdx + 1));
+            switch (key) {
+                case "CFBundleIdentifier":
+                    bundleId = value;
+                    break;
+                case "CFBundleName":
+                    name = value;
+                    break;
+                case "CFBundleDisplayName":
+                    displayName = value;
+                    break;
+                case "CFBundleShortVersionString":
+                    shortVersion = value;
+                    break;
+                case "CFBundleVersion":
+                    version = value;
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+    return apps;
+}
+export class AppLifecycle {
+    screen;
+    targetResolver;
+    udid = null;
+    udidResolved = false;
+    udidResolvedAt = 0;
+    static UDID_TTL_MS = 5_000;
+    udidInflight = null;
+    devicectlAvailable = null;
+    idbAvailable = null;
+    installedAppsCache = null;
+    INSTALLED_CACHE_MS = 30_000;
+    constructor(screen, targetResolver) {
+        this.screen = screen;
+        this.targetResolver = targetResolver;
+    }
+    setTargetResolver(resolver) {
+        this.targetResolver = resolver;
+    }
+    async pickTransport() {
+        if (!this.targetResolver) {
+            return { preferSimulator: false, simulatorUdid: "booted" };
+        }
+        const info = await this.targetResolver.resolve();
+        const preferSimulator = info.target === "simulator";
+        const simulatorUdid = info.target === "simulator" && info.udid ? info.udid : "booted";
+        return { preferSimulator, simulatorUdid };
+    }
+    async getUdid() {
+        if (this.udidResolved &&
+            this.udid &&
+            Date.now() - this.udidResolvedAt < AppLifecycle.UDID_TTL_MS) {
+            return this.udid;
+        }
+        if (this.udidInflight)
+            return this.udidInflight;
+        const work = (async () => {
+            try {
+                const hasXcrun = await hasBinary("xcrun");
+                if (!hasXcrun)
+                    return null;
+                const res = await runCommand("xcrun", ["devicectl", "list", "devices", "--json-output", "-"], { timeoutMs: 8000 });
+                if (res.code !== 0)
+                    return null;
+                const parsed = JSON.parse(res.stdout);
+                const devices = parsed.result?.devices ?? [];
+                const real = devices.find((d) => {
+                    const platform = d.hardwareProperties?.platform?.toLowerCase() ?? "";
+                    const tunnel = d.connectionProperties?.tunnelState?.toLowerCase() ?? "";
+                    return platform.includes("ios") && tunnel === "connected";
+                });
+                if (real?.identifier) {
+                    this.udid = real.identifier;
+                    this.udidResolved = true;
+                    this.udidResolvedAt = Date.now();
+                    return this.udid;
+                }
+                const anyIos = devices.find((d) => (d.hardwareProperties?.platform?.toLowerCase() ?? "").includes("ios"));
+                if (anyIos?.identifier) {
+                    this.udid = anyIos.identifier;
+                    this.udidResolved = true;
+                    this.udidResolvedAt = Date.now();
+                    return this.udid;
+                }
+            }
+            catch {
+            }
+            return null;
+        })();
+        this.udidInflight = work;
+        try {
+            return await work;
+        }
+        finally {
+            this.udidInflight = null;
+        }
+    }
+    async checkDevicectl() {
+        if (this.devicectlAvailable !== null)
+            return this.devicectlAvailable;
+        const hasXcrun = await hasBinary("xcrun");
+        if (!hasXcrun) {
+            this.devicectlAvailable = false;
+            return false;
+        }
+        const res = await runCommand("xcrun", ["devicectl", "--help"], {
+            timeoutMs: 4000,
+        });
+        this.devicectlAvailable = res.code === 0;
+        return this.devicectlAvailable;
+    }
+    async checkIdb() {
+        if (this.idbAvailable !== null)
+            return this.idbAvailable;
+        this.idbAvailable = await hasBinary("idb");
+        return this.idbAvailable;
+    }
+    async launchApp(bundleId) {
+        const transport = await this.pickTransport();
+        if (transport.preferSimulator) {
+            const simUdid = transport.simulatorUdid;
+            const res = await runCommand("xcrun", ["simctl", "launch", simUdid, bundleId], { timeoutMs: 15_000 });
+            if (res.code === 0) {
+                return { success: true, transport: "simctl", details: { udid: simUdid } };
+            }
+            return {
+                success: false,
+                transport: "simctl",
+                error: `simctl launch failed: ${(res.stderr || res.stdout).trim()}`,
+                details: { udid: simUdid },
+            };
+        }
+        const udid = await this.getUdid();
+        if (udid && (await this.checkDevicectl())) {
+            const res = await runCommand("xcrun", [
+                "devicectl",
+                "device",
+                "process",
+                "launch",
+                "--device",
+                udid,
+                "--terminate-existing",
+                bundleId,
+            ], { timeoutMs: 30_000 });
+            if (res.code === 0) {
+                return { success: true, transport: "devicectl", details: { udid } };
+            }
+            const devicectlError = res.stderr || res.stdout;
+            if (!(await this.checkIdb())) {
+                return {
+                    success: false,
+                    transport: "devicectl",
+                    error: `devicectl launch failed: ${devicectlError.trim()}`,
+                };
+            }
+        }
+        if (await this.checkIdb()) {
+            const idbArgs = ["launch", bundleId];
+            if (udid)
+                idbArgs.push("--udid", udid);
+            const res = await runCommand("idb", idbArgs, { timeoutMs: 30_000 });
+            if (res.code === 0) {
+                return { success: true, transport: "idb", details: { udid } };
+            }
+            if (!udid) {
+            }
+            else {
+                return {
+                    success: false,
+                    transport: "idb",
+                    error: `idb launch failed: ${(res.stderr || res.stdout).trim()}`,
+                };
+            }
+        }
+        if (!udid) {
+            const res = await runCommand("xcrun", ["simctl", "launch", "booted", bundleId], { timeoutMs: 15_000 });
+            if (res.code === 0) {
+                return { success: true, transport: "simctl" };
+            }
+            return {
+                success: false,
+                transport: "simctl",
+                error: `simctl launch failed: ${(res.stderr || res.stdout).trim()}`,
+            };
+        }
+        return {
+            success: false,
+            transport: "none",
+            error: "No working launch transport found. Install Xcode (for devicectl) " +
+                "or idb (https://fbidb.io/) to launch apps on a real device.",
+        };
+    }
+    async terminateApp(bundleId) {
+        const transport = await this.pickTransport();
+        if (transport.preferSimulator) {
+            const simUdid = transport.simulatorUdid;
+            const res = await runCommand("xcrun", ["simctl", "terminate", simUdid, bundleId], { timeoutMs: 10_000 });
+            if (res.code === 0) {
+                return { success: true, transport: "simctl", details: { udid: simUdid } };
+            }
+            return {
+                success: false,
+                transport: "simctl",
+                error: `simctl terminate failed: ${(res.stderr || res.stdout).trim()}`,
+                details: { udid: simUdid },
+            };
+        }
+        const udid = await this.getUdid();
+        if (udid && (await this.checkDevicectl())) {
+            const res = await runCommand("xcrun", [
+                "devicectl",
+                "device",
+                "process",
+                "terminate",
+                "--device",
+                udid,
+                "--bundle-identifier",
+                bundleId,
+            ], { timeoutMs: 15_000 });
+            if (res.code === 0) {
+                return { success: true, transport: "devicectl" };
+            }
+        }
+        if (await this.checkIdb()) {
+            const args = ["terminate", bundleId];
+            if (udid)
+                args.push("--udid", udid);
+            const res = await runCommand("idb", args, { timeoutMs: 15_000 });
+            if (res.code === 0) {
+                return { success: true, transport: "idb" };
+            }
+        }
+        if (!udid) {
+            const res = await runCommand("xcrun", ["simctl", "terminate", "booted", bundleId], { timeoutMs: 10_000 });
+            if (res.code === 0) {
+                return { success: true, transport: "simctl" };
+            }
+            return {
+                success: false,
+                transport: "simctl",
+                error: `simctl terminate failed: ${(res.stderr || res.stdout).trim()}`,
+            };
+        }
+        return {
+            success: false,
+            transport: "none",
+            error: "Failed to terminate via devicectl or idb.",
+        };
+    }
+    async activateApp(bundleId) {
+        if (this.screen) {
+            const reachable = await this.screen.isAvailable();
+            if (reachable) {
+                const res = await this.screen.activateApp(bundleId);
+                if (res.success) {
+                    return { success: true, transport: "wda" };
+                }
+            }
+        }
+        return this.launchApp(bundleId);
+    }
+    async listInstalledApps() {
+        const transport = await this.pickTransport();
+        const deviceUdidForKey = transport.preferSimulator
+            ? null
+            : await this.getUdid();
+        const cacheKey = transport.preferSimulator
+            ? `sim:${transport.simulatorUdid}`
+            : `device:${deviceUdidForKey ?? "none"}`;
+        if (this.installedAppsCache &&
+            this.installedAppsCache.key === cacheKey &&
+            Date.now() - this.installedAppsCache.at < this.INSTALLED_CACHE_MS) {
+            return { success: true, apps: this.installedAppsCache.apps };
+        }
+        if (transport.preferSimulator) {
+            return this.listInstalledAppsSimulator(transport.simulatorUdid, cacheKey);
+        }
+        const udid = deviceUdidForKey;
+        if (!udid) {
+            return {
+                success: false,
+                apps: [],
+                error: "No real iOS device connected. Connect a device via USB-C and trust this Mac.",
+            };
+        }
+        if (!(await this.checkDevicectl())) {
+            return {
+                success: false,
+                apps: [],
+                error: "xcrun devicectl not available — install Xcode 15 or newer.",
+            };
+        }
+        const res = await runCommand("xcrun", [
+            "devicectl",
+            "device",
+            "info",
+            "apps",
+            "--device",
+            udid,
+            "--json-output",
+            "-",
+        ], { timeoutMs: 20_000 });
+        if (res.code !== 0) {
+            return {
+                success: false,
+                apps: [],
+                error: `devicectl info apps failed: ${(res.stderr || res.stdout).trim()}`,
+            };
+        }
+        try {
+            const parsed = JSON.parse(res.stdout);
+            const apps = (parsed.result?.apps ?? [])
+                .filter((a) => !!a.bundleIdentifier)
+                .map((a) => ({
+                bundleId: a.bundleIdentifier,
+                name: a.name ?? a.bundleIdentifier,
+                version: a.shortVersionString ?? a.version,
+            }));
+            this.installedAppsCache = { at: Date.now(), key: cacheKey, apps };
+            return { success: true, apps };
+        }
+        catch (err) {
+            return {
+                success: false,
+                apps: [],
+                error: `Failed to parse devicectl output: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+    }
+    async listInstalledAppsSimulator(simUdid, cacheKey) {
+        const res = await runCommand("xcrun", ["simctl", "listapps", simUdid], { timeoutMs: 15_000 });
+        if (res.code !== 0) {
+            return {
+                success: false,
+                apps: [],
+                error: `simctl listapps failed: ${(res.stderr || res.stdout).trim()}`,
+            };
+        }
+        const apps = parseSimctlListapps(res.stdout);
+        this.installedAppsCache = { at: Date.now(), key: cacheKey, apps };
+        return { success: true, apps };
+    }
+    async getActiveApp() {
+        if (!this.screen) {
+            return {
+                success: false,
+                error: "ScreenManager not provided — cannot query active app via WDA.",
+            };
+        }
+        return this.screen.getActiveAppInfo();
+    }
+    reset() {
+        this.udid = null;
+        this.udidResolved = false;
+        this.udidResolvedAt = 0;
+        this.devicectlAvailable = null;
+        this.idbAvailable = null;
+        this.installedAppsCache = null;
+    }
+}

package/dist/camera-image-writer.d.ts

@@ -0,0 +1,43 @@
+import { syncCameraRegistry, type SyncResult } from "./camera-registry-sync.js";
+export declare const SUPPORTED_EXTENSIONS: readonly ["jpg", "jpeg", "png", "webp", "heic"];
+export type SupportedExt = (typeof SUPPORTED_EXTENSIONS)[number];
+export declare const MAX_IMAGE_BYTES: number;
+export interface AddCameraImageOptions {
+    imageKey: string;
+    imageBase64: string;
+    contentType?: string;
+    overwrite?: boolean;
+    subDir?: string;
+}
+export interface AddCameraImageWarning {
+    code: "content-type-mismatch" | "content-type-unrecognized" | "image-larger-than-typical";
+    message: string;
+}
+export interface AddCameraImageResult {
+    written: string;
+    registry: string;
+    registered: string[];
+    detectedContentType: string;
+    detectedExt: SupportedExt;
+    replaced: boolean;
+    removedSiblingPath?: string;
+    bytes: number;
+    warnings: AddCameraImageWarning[];
+    registryState: SyncResult["writtenOrUnchanged"];
+}
+export declare class AddCameraImageError extends Error {
+    readonly code: string;
+    readonly remediation: string;
+    constructor(code: string, message: string, remediation: string);
+}
+export declare function validateImageKey(key: string): void;
+export declare function validateSubDir(subDir: string): void;
+export declare function detectImageType(bytes: Uint8Array): {
+    ext: SupportedExt;
+    mime: string;
+} | null;
+export declare function normalizeContentTypeHint(hint: string): SupportedExt | null;
+export interface AddCameraImageDeps {
+    syncCameraRegistry?: typeof syncCameraRegistry;
+}
+export declare function addCameraImage(projectDir: string, options: AddCameraImageOptions, deps?: AddCameraImageDeps): Promise<AddCameraImageResult>;