@ceraph/react-native-mcp 0.2.2 → 0.3.2

package/dist/simulator-boot.js

@@ -0,0 +1,227 @@
+import { spawn } from "node:child_process";
+export async function runXcrun(cmd, args, timeoutMs = 30_000) {
+    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 {
+            }
+        }, timeoutMs);
+        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 });
+        });
+    });
+}
+export const defaultBootSimulatorDeps = {
+    runner: runXcrun,
+};
+export function parseIosRuntimeVersion(runtimeKey) {
+    const lower = runtimeKey.toLowerCase();
+    if (!lower.includes("ios") && !lower.includes("iphone"))
+        return null;
+    const re = /ios[-\s]?(\d+)(?:[-.](\d+))?/i;
+    const m = re.exec(runtimeKey);
+    if (!m)
+        return null;
+    const major = Number(m[1]);
+    const minor = m[2] ? Number(m[2]) : 0;
+    if (!Number.isFinite(major))
+        return null;
+    return { major, minor, label: `iOS ${major}${m[2] ? "." + minor : ""}` };
+}
+const VARIANT_MODIFIERS = ["pro", "max", "plus", "mini", "se", "air"];
+function parseModelNumber(name) {
+    const m = /\b(\d+)\b/.exec(name);
+    if (!m)
+        return 0;
+    const n = Number(m[1]);
+    return Number.isFinite(n) ? n : 0;
+}
+function countModifiers(name) {
+    const tokens = name.toLowerCase().split(/\s+/);
+    let count = 0;
+    for (const t of tokens) {
+        if (VARIANT_MODIFIERS.includes(t))
+            count++;
+    }
+    return count;
+}
+export function pickBestSimulator(list, deviceType) {
+    const wanted = (deviceType ?? "").trim().toLowerCase();
+    const candidates = [];
+    for (const [runtimeKey, devices] of Object.entries(list.devices ?? {})) {
+        const runtime = parseIosRuntimeVersion(runtimeKey);
+        if (!runtime)
+            continue;
+        if (!Array.isArray(devices))
+            continue;
+        for (const dev of devices) {
+            if (!dev.udid || !dev.name)
+                continue;
+            if (dev.isAvailable === false)
+                continue;
+            const lowerName = dev.name.toLowerCase();
+            if (wanted && !lowerName.includes(wanted))
+                continue;
+            candidates.push({
+                udid: dev.udid,
+                name: dev.name,
+                runtimeLabel: runtime.label,
+                state: dev.state ?? "Unknown",
+                major: runtime.major,
+                minor: runtime.minor,
+                modifiers: countModifiers(dev.name),
+                modelNumber: parseModelNumber(dev.name),
+            });
+        }
+    }
+    if (candidates.length === 0)
+        return null;
+    candidates.sort((a, b) => {
+        if (b.major !== a.major)
+            return b.major - a.major;
+        if (b.minor !== a.minor)
+            return b.minor - a.minor;
+        if (a.modifiers !== b.modifiers)
+            return a.modifiers - b.modifiers;
+        if (b.modelNumber !== a.modelNumber)
+            return b.modelNumber - a.modelNumber;
+        return a.name.localeCompare(b.name);
+    });
+    const top = candidates[0];
+    return {
+        udid: top.udid,
+        name: top.name,
+        runtimeLabel: top.runtimeLabel,
+        state: top.state,
+    };
+}
+export function findSimulatorByUdid(list, udid) {
+    for (const [runtimeKey, devices] of Object.entries(list.devices ?? {})) {
+        const runtime = parseIosRuntimeVersion(runtimeKey);
+        if (!runtime)
+            continue;
+        if (!Array.isArray(devices))
+            continue;
+        for (const dev of devices) {
+            if (dev.udid !== udid)
+                continue;
+            return {
+                udid: dev.udid,
+                name: dev.name ?? udid,
+                runtimeLabel: runtime.label,
+                state: dev.state ?? "Unknown",
+            };
+        }
+    }
+    return null;
+}
+export function isAlreadyBootedError(stderr) {
+    const s = stderr.toLowerCase();
+    return (s.includes("unable to boot device in current state") &&
+        s.includes("booted"));
+}
+export async function bootSimulator(opts = {}, deps = defaultBootSimulatorDeps) {
+    const bootTimeoutMs = opts.bootTimeoutMs ?? 120_000;
+    const runner = deps.runner;
+    let chosen;
+    const listResult = await runner("xcrun", ["simctl", "list", "devices", "--json"], 15_000);
+    if (listResult.code === 127) {
+        throw new Error("`xcrun` not found on PATH. Install Xcode Command Line Tools " +
+            "(`xcode-select --install`) and try again.");
+    }
+    if (listResult.code !== 0) {
+        throw new Error(`xcrun simctl list devices failed (exit ${listResult.code}): ${listResult.stderr || listResult.stdout || "no output"}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(listResult.stdout);
+    }
+    catch (err) {
+        throw new Error(`Failed to parse simctl device list as JSON: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (opts.udid) {
+        const found = findSimulatorByUdid(parsed, opts.udid);
+        if (!found) {
+            throw new Error(`No iOS simulator with udid ${opts.udid} found in the simctl ` +
+                "listing. Run `xcrun simctl list devices` to see available udids.");
+        }
+        chosen = found;
+    }
+    else {
+        const picked = pickBestSimulator(parsed, opts.deviceType);
+        if (!picked) {
+            throw new Error(opts.deviceType
+                ? `No iOS simulators matching "${opts.deviceType}" are available. ` +
+                    "Open Xcode → Settings → Platforms → install an iOS simulator " +
+                    "runtime, or pick a different deviceType."
+                : "No iOS simulators are available on this Mac. Open Xcode → " +
+                    "Settings → Platforms → install an iOS simulator runtime.");
+        }
+        chosen = picked;
+    }
+    if (chosen.state.toLowerCase() === "booted") {
+        return {
+            udid: chosen.udid,
+            deviceType: chosen.name,
+            alreadyBooted: true,
+            booted: true,
+            runtime: chosen.runtimeLabel,
+            durationMs: 0,
+        };
+    }
+    const start = Date.now();
+    const bootResult = await runner("xcrun", ["simctl", "boot", chosen.udid], 30_000);
+    if (bootResult.code !== 0 && !isAlreadyBootedError(bootResult.stderr)) {
+        throw new Error(`Failed to boot simulator ${chosen.name} (${chosen.udid}): ${bootResult.stderr || bootResult.stdout || "no output"}`);
+    }
+    const bootstatus = await runner("xcrun", ["simctl", "bootstatus", chosen.udid, "-b"], bootTimeoutMs + 5_000);
+    if (bootstatus.code !== 0) {
+        throw new Error(`simctl bootstatus failed for ${chosen.name} (${chosen.udid}): ${bootstatus.stderr || bootstatus.stdout || "no output"}`);
+    }
+    return {
+        udid: chosen.udid,
+        deviceType: chosen.name,
+        alreadyBooted: false,
+        booted: true,
+        runtime: chosen.runtimeLabel,
+        durationMs: Date.now() - start,
+    };
+}

package/dist/target.d.ts

@@ -0,0 +1,48 @@
+export type Target = "device" | "simulator";
+export type TargetPreference = Target | "auto";
+export interface TargetInfo {
+    target: Target;
+    udid: string | null;
+    baseUrl: string;
+    wdaReady: boolean;
+    reason: "env-override-device" | "env-override-simulator" | "auto-prefer-device" | "auto-only-simulator" | "auto-no-target-found";
+}
+export interface BootedSimulator {
+    udid: string;
+    name: string;
+    runtime?: string;
+}
+export interface AppLifecycleLike {
+    getUdid(): Promise<string | null>;
+}
+export declare function preferenceFromEnv(raw: string | undefined): TargetPreference;
+export declare function listBootedSimulators(): Promise<BootedSimulator[]>;
+export declare function parseWdaPort(stdout: string): number | null;
+export declare const DEFAULT_DEVICE_WDA_BASE_URL = "http://localhost:8100";
+export declare function simulatorWdaBaseUrl(port: number): string;
+export declare class TargetResolver {
+    private apps;
+    private readPreference;
+    private cached;
+    private cachedAt;
+    private readonly cacheTtlMs;
+    private inflight;
+    private stateVersion;
+    private simulatorWdaPort;
+    private simulatorWdaUdid;
+    constructor(opts?: {
+        apps?: AppLifecycleLike;
+        readPreference?: () => TargetPreference;
+        cacheTtlMs?: number;
+    });
+    setAppLifecycle(apps: AppLifecycleLike): void;
+    setSimulatorWdaPort(port: number, udid: string): void;
+    clearSimulatorWdaPort(): void;
+    getSimulatorWdaPort(): number | null;
+    getSimulatorWdaUdid(): string | null;
+    invalidate(): void;
+    getBaseUrl(): Promise<string>;
+    getTarget(): Promise<Target>;
+    resolve(): Promise<TargetInfo>;
+    reset(): void;
+}

package/dist/target.js

@@ -0,0 +1,267 @@
+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 ?? 8000);
+        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 });
+        });
+    });
+}
+export function preferenceFromEnv(raw) {
+    const v = (raw ?? "").trim().toLowerCase();
+    if (v === "device")
+        return "device";
+    if (v === "simulator" || v === "sim")
+        return "simulator";
+    return "auto";
+}
+export async function listBootedSimulators() {
+    const res = await runCommand("xcrun", [
+        "simctl",
+        "list",
+        "devices",
+        "booted",
+        "-j",
+    ]);
+    if (res.code !== 0)
+        return [];
+    try {
+        const parsed = JSON.parse(res.stdout);
+        const out = [];
+        const devices = parsed.devices ?? {};
+        for (const [runtimeKey, list] of Object.entries(devices)) {
+            const isIos = runtimeKey.toLowerCase().includes("ios") ||
+                runtimeKey.toLowerCase().includes("iphone");
+            if (!isIos)
+                continue;
+            if (!Array.isArray(list))
+                continue;
+            for (const dev of list) {
+                if (!dev.udid)
+                    continue;
+                if ((dev.state ?? "").toLowerCase() !== "booted")
+                    continue;
+                out.push({
+                    udid: dev.udid,
+                    name: dev.name ?? dev.udid,
+                    runtime: dev.runtime ?? runtimeKey,
+                });
+            }
+        }
+        return out;
+    }
+    catch {
+        return [];
+    }
+}
+export function parseWdaPort(stdout) {
+    const re = /ServerURLHere->https?:\/\/[^:/\s]+:(\d{2,5})<-ServerURLHere/;
+    const m = re.exec(stdout);
+    if (!m)
+        return null;
+    const port = Number(m[1]);
+    if (!Number.isFinite(port) || port < 1 || port > 65535)
+        return null;
+    return port;
+}
+export const DEFAULT_DEVICE_WDA_BASE_URL = "http://localhost:8100";
+export function simulatorWdaBaseUrl(port) {
+    return `http://localhost:${port}`;
+}
+export class TargetResolver {
+    apps;
+    readPreference;
+    cached = null;
+    cachedAt = 0;
+    cacheTtlMs;
+    inflight = null;
+    stateVersion = 0;
+    simulatorWdaPort = null;
+    simulatorWdaUdid = null;
+    constructor(opts = {}) {
+        this.apps = opts.apps ?? null;
+        this.readPreference = opts.readPreference ?? (() => preferenceFromEnv(process.env.CERAPH_TARGET));
+        this.cacheTtlMs = opts.cacheTtlMs ?? 5_000;
+    }
+    setAppLifecycle(apps) {
+        this.apps = apps;
+        this.cached = null;
+        this.stateVersion++;
+    }
+    setSimulatorWdaPort(port, udid) {
+        this.simulatorWdaPort = port;
+        this.simulatorWdaUdid = udid;
+        this.cached = null;
+        this.stateVersion++;
+    }
+    clearSimulatorWdaPort() {
+        this.simulatorWdaPort = null;
+        this.simulatorWdaUdid = null;
+        this.cached = null;
+        this.stateVersion++;
+    }
+    getSimulatorWdaPort() {
+        return this.simulatorWdaPort;
+    }
+    getSimulatorWdaUdid() {
+        return this.simulatorWdaUdid;
+    }
+    invalidate() {
+        this.cached = null;
+        this.stateVersion++;
+    }
+    async getBaseUrl() {
+        const info = await this.resolve();
+        return info.baseUrl;
+    }
+    async getTarget() {
+        const info = await this.resolve();
+        return info.target;
+    }
+    async resolve() {
+        if (this.cached &&
+            this.cacheTtlMs > 0 &&
+            Date.now() - this.cachedAt < this.cacheTtlMs) {
+            return this.cached;
+        }
+        if (this.inflight)
+            return this.inflight;
+        const versionAtStart = this.stateVersion;
+        const work = (async () => {
+            const pref = this.readPreference();
+            if (pref === "device") {
+                const udid = (await this.apps?.getUdid()) ?? null;
+                return {
+                    target: "device",
+                    udid,
+                    baseUrl: DEFAULT_DEVICE_WDA_BASE_URL,
+                    wdaReady: true,
+                    reason: "env-override-device",
+                };
+            }
+            if (pref === "simulator") {
+                const sims = await listBootedSimulators();
+                const picked = this.simulatorWdaUdid
+                    ? sims.find((s) => s.udid === this.simulatorWdaUdid) ?? sims[0]
+                    : sims[0];
+                const pickedUdid = picked?.udid ?? this.simulatorWdaUdid ?? null;
+                const wdaHostStillBooted = this.simulatorWdaUdid !== null &&
+                    sims.some((s) => s.udid === this.simulatorWdaUdid);
+                const portMatchesSim = this.simulatorWdaPort !== null &&
+                    this.simulatorWdaUdid !== null &&
+                    wdaHostStillBooted &&
+                    pickedUdid === this.simulatorWdaUdid;
+                return {
+                    target: "simulator",
+                    udid: pickedUdid,
+                    baseUrl: portMatchesSim
+                        ? simulatorWdaBaseUrl(this.simulatorWdaPort)
+                        : DEFAULT_DEVICE_WDA_BASE_URL,
+                    wdaReady: portMatchesSim,
+                    reason: "env-override-simulator",
+                };
+            }
+            const [deviceUdid, sims] = await Promise.all([
+                this.apps?.getUdid() ?? Promise.resolve(null),
+                listBootedSimulators(),
+            ]);
+            if (deviceUdid) {
+                return {
+                    target: "device",
+                    udid: deviceUdid,
+                    baseUrl: DEFAULT_DEVICE_WDA_BASE_URL,
+                    wdaReady: true,
+                    reason: "auto-prefer-device",
+                };
+            }
+            if (sims.length > 0) {
+                const picked = this.simulatorWdaUdid
+                    ? sims.find((s) => s.udid === this.simulatorWdaUdid) ?? sims[0]
+                    : sims[0];
+                const wdaHostStillBooted = this.simulatorWdaUdid !== null &&
+                    sims.some((s) => s.udid === this.simulatorWdaUdid);
+                const portMatchesSim = this.simulatorWdaPort !== null &&
+                    this.simulatorWdaUdid !== null &&
+                    wdaHostStillBooted &&
+                    picked.udid === this.simulatorWdaUdid;
+                return {
+                    target: "simulator",
+                    udid: picked.udid,
+                    baseUrl: portMatchesSim
+                        ? simulatorWdaBaseUrl(this.simulatorWdaPort)
+                        : DEFAULT_DEVICE_WDA_BASE_URL,
+                    wdaReady: portMatchesSim,
+                    reason: "auto-only-simulator",
+                };
+            }
+            return {
+                target: "device",
+                udid: null,
+                baseUrl: DEFAULT_DEVICE_WDA_BASE_URL,
+                wdaReady: true,
+                reason: "auto-no-target-found",
+            };
+        })();
+        this.inflight = work;
+        try {
+            const info = await work;
+            if (this.stateVersion === versionAtStart) {
+                this.cached = info;
+                this.cachedAt = Date.now();
+            }
+            return info;
+        }
+        finally {
+            this.inflight = null;
+        }
+    }
+    reset() {
+        this.cached = null;
+        this.inflight = null;
+        this.simulatorWdaPort = null;
+        this.simulatorWdaUdid = null;
+        this.stateVersion++;
+    }
+}

package/dist/uninstall/cli-runner.d.ts

@@ -0,0 +1,32 @@
+import { type PromptDeps } from "../init/prompt.js";
+import { type UninstallStep, type UninstallWalkthroughResult } from "./walkthrough.js";
+export interface CliRunnerOpts extends PromptDeps {
+    argv: string[];
+    cwd?: string;
+    spawnRemove?: (input: {
+        bin: string;
+        args: string[];
+        cwd: string;
+    }) => Promise<{
+        exitCode: number;
+    }>;
+}
+export interface CliRunnerResult {
+    exitCode: 0 | 1;
+    walkthrough: UninstallWalkthroughResult | null;
+    parsedFlags: ParsedFlags;
+}
+interface ParsedFlags {
+    yes: boolean;
+    purgeImages: boolean;
+    global: boolean;
+    dryRun: boolean;
+    projectDir: string | null;
+    help: boolean;
+    unknown: string[];
+}
+export declare function runUninstallCli(opts: CliRunnerOpts): Promise<CliRunnerResult>;
+export declare function formatStepLine(step: UninstallStep): string;
+export declare function formatSummary(result: UninstallWalkthroughResult): string;
+export declare function parseArgs(argv: string[]): ParsedFlags;
+export {};