@ceraph/react-native-mcp 0.3.3 → 0.4.6

package/dist/app-lifecycle.js

@@ -1,487 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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>;