@ceraph/react-native-mcp 0.2.2 → 0.3.2

package/dist/iproxy-manager.js

@@ -0,0 +1,216 @@
+import { spawn } from "node:child_process";
+const DEFAULT_LOCAL = 8100;
+const DEFAULT_DEVICE = 8100;
+const MAX_LOG_LINES = 50;
+function defaultWhich(bin) {
+    return new Promise((resolve) => {
+        let stdout = "";
+        let settled = false;
+        const child = spawn("which", [bin], {
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.on("error", () => {
+            if (!settled) {
+                settled = true;
+                resolve(null);
+            }
+        });
+        child.on("exit", (code) => {
+            if (settled)
+                return;
+            settled = true;
+            if (code !== 0)
+                resolve(null);
+            else {
+                const trimmed = stdout.trim();
+                resolve(trimmed.length > 0 ? trimmed : null);
+            }
+        });
+    });
+}
+export class IproxyManager {
+    child = null;
+    udid = null;
+    localPort;
+    devicePort;
+    stderrBuffer = [];
+    spawnFn;
+    whichFn;
+    startInFlight = null;
+    constructor(opts = {}) {
+        this.localPort = opts.localPort ?? DEFAULT_LOCAL;
+        this.devicePort = opts.devicePort ?? DEFAULT_DEVICE;
+        this.spawnFn = opts.spawnFn ?? spawn;
+        this.whichFn = opts.whichFn ?? defaultWhich;
+    }
+    isRunning() {
+        return this.child !== null && this.child.exitCode === null;
+    }
+    async start(udid) {
+        while (true) {
+            if (this.isRunning()) {
+                return {
+                    ok: false,
+                    reason: "already-running",
+                    pid: this.child?.pid,
+                };
+            }
+            if (!this.startInFlight)
+                break;
+            await this.startInFlight.catch(() => undefined);
+        }
+        const myInFlight = this.startInner(udid);
+        this.startInFlight = myInFlight;
+        try {
+            return await myInFlight;
+        }
+        finally {
+            if (this.startInFlight === myInFlight) {
+                this.startInFlight = null;
+            }
+        }
+    }
+    async startInner(udid) {
+        if (this.isRunning()) {
+            return {
+                ok: false,
+                reason: "already-running",
+                pid: this.child?.pid,
+            };
+        }
+        const binPath = await this.whichFn("iproxy");
+        if (!binPath) {
+            return { ok: false, reason: "not-installed" };
+        }
+        this.udid = udid;
+        this.stderrBuffer = [];
+        let child;
+        try {
+            child = this.spawnFn(binPath, [
+                String(this.localPort),
+                String(this.devicePort),
+                "-u",
+                udid,
+            ], { stdio: ["ignore", "pipe", "pipe"] });
+        }
+        catch (err) {
+            this.appendStderr(`iproxy spawn threw: ${err instanceof Error ? err.message : String(err)}`);
+            return { ok: false, reason: "spawn-failed", stderr: [...this.stderrBuffer] };
+        }
+        child.stderr?.on("data", (chunk) => {
+            const text = chunk.toString();
+            for (const line of text.split(/\r?\n/)) {
+                if (line.trim().length === 0)
+                    continue;
+                this.appendStderr(line);
+            }
+        });
+        child.stdout?.on("data", (chunk) => {
+            const text = chunk.toString();
+            for (const line of text.split(/\r?\n/)) {
+                if (line.trim().length === 0)
+                    continue;
+                this.appendStderr(`[stdout] ${line}`);
+            }
+        });
+        const earlyExit = await this.detectEarlyExit(child, 50);
+        if (earlyExit) {
+            this.child = null;
+            return {
+                ok: false,
+                reason: "spawn-failed",
+                stderr: [...this.stderrBuffer],
+            };
+        }
+        this.child = child;
+        child.on("exit", () => {
+            if (this.child === child) {
+                this.child = null;
+            }
+        });
+        return {
+            ok: true,
+            pid: child.pid,
+            stderr: [...this.stderrBuffer],
+        };
+    }
+    async stop() {
+        if (this.startInFlight) {
+            await this.startInFlight.catch(() => undefined);
+        }
+        const child = this.child;
+        if (!child)
+            return;
+        this.child = null;
+        if (child.exitCode !== null)
+            return;
+        return new Promise((resolve) => {
+            let settled = false;
+            let killTimer = null;
+            let fallbackTimer = null;
+            const finish = () => {
+                if (settled)
+                    return;
+                settled = true;
+                if (killTimer)
+                    clearTimeout(killTimer);
+                if (fallbackTimer)
+                    clearTimeout(fallbackTimer);
+                resolve();
+            };
+            child.once("exit", finish);
+            try {
+                child.kill("SIGTERM");
+            }
+            catch {
+                finish();
+                return;
+            }
+            killTimer = setTimeout(() => {
+                if (settled)
+                    return;
+                try {
+                    child.kill("SIGKILL");
+                }
+                catch {
+                }
+                fallbackTimer = setTimeout(finish, 100);
+                fallbackTimer.unref();
+            }, 1000);
+            killTimer.unref();
+        });
+    }
+    async restart(udid) {
+        await this.stop();
+        return this.start(udid ?? this.udid ?? "");
+    }
+    getStderr() {
+        return [...this.stderrBuffer];
+    }
+    appendStderr(line) {
+        this.stderrBuffer.push(line);
+        if (this.stderrBuffer.length > MAX_LOG_LINES) {
+            this.stderrBuffer.shift();
+        }
+    }
+    detectEarlyExit(child, withinMs) {
+        return new Promise((resolve) => {
+            let settled = false;
+            const finish = (value) => {
+                if (settled)
+                    return;
+                settled = true;
+                resolve(value);
+            };
+            const onExit = () => finish(true);
+            child.once("exit", onExit);
+            setTimeout(() => {
+                child.off("exit", onExit);
+                finish(false);
+            }, withinMs).unref();
+        });
+    }
+}

package/dist/mac-caffeinate.d.ts

@@ -0,0 +1,10 @@
+import { spawn as nodeSpawn } from "node:child_process";
+export interface CaffeinateResult {
+    applied: boolean;
+    reason: "started" | "already-active" | "not-darwin" | "spawn-failed";
+}
+export type Spawner = typeof nodeSpawn;
+export declare function _resetForTesting(): void;
+export declare function _setSpawnerForTesting(fn: Spawner | null): void;
+export declare function enableCaffeinate(): CaffeinateResult;
+export declare function disableCaffeinate(): void;

package/dist/mac-caffeinate.js

@@ -0,0 +1,56 @@
+import { spawn as nodeSpawn } from "node:child_process";
+let child = null;
+let active = false;
+let spawnerOverride = null;
+export function _resetForTesting() {
+    child = null;
+    active = false;
+    spawnerOverride = null;
+}
+export function _setSpawnerForTesting(fn) {
+    spawnerOverride = fn;
+}
+export function enableCaffeinate() {
+    if (process.platform !== "darwin") {
+        return { applied: false, reason: "not-darwin" };
+    }
+    if (active && child && !child.killed) {
+        return { applied: true, reason: "already-active" };
+    }
+    try {
+        const spawnFn = spawnerOverride ?? nodeSpawn;
+        const proc = spawnFn("caffeinate", ["-di", "-w", String(process.pid)], {
+            detached: true,
+            stdio: "ignore",
+        });
+        if (typeof proc.unref === "function") {
+            proc.unref();
+        }
+        child = proc;
+        active = true;
+        const thisChild = proc;
+        proc.once("exit", () => {
+            if (child === thisChild) {
+                child = null;
+                active = false;
+            }
+        });
+        return { applied: true, reason: "started" };
+    }
+    catch {
+        return { applied: false, reason: "spawn-failed" };
+    }
+}
+export function disableCaffeinate() {
+    if (!active)
+        return;
+    if (child) {
+        try {
+            child.kill("SIGTERM");
+        }
+        catch {
+        }
+    }
+    child = null;
+    active = false;
+}

package/dist/permission-interceptor.d.ts

@@ -0,0 +1,29 @@
+import type { ScreenManager } from "./screen.js";
+export type InterceptorMode = "auto-accept" | "ask" | "off";
+export interface PermissionInterceptorOpts {
+    screen: ScreenManager;
+    mode: InterceptorMode;
+    onDialog?: (info: {
+        title: string;
+        body: string;
+    }) => Promise<"accept" | "deny">;
+}
+export interface DialogInfo {
+    title: string;
+    body: string;
+    action: "accept" | "deny";
+}
+export interface InterceptResult {
+    handled: boolean;
+    dialog?: DialogInfo;
+}
+export declare class PermissionInterceptor {
+    private readonly screen;
+    private mode;
+    private readonly onDialog?;
+    constructor(opts: PermissionInterceptorOpts);
+    getMode(): InterceptorMode;
+    setMode(mode: InterceptorMode): void;
+    checkAndHandle(): Promise<InterceptResult>;
+}
+export declare function modeFromEnv(value: string | undefined): InterceptorMode;

package/dist/permission-interceptor.js

@@ -0,0 +1,185 @@
+const KNOWN_DIALOGS = [
+    {
+        id: "camera",
+        titlePattern: /Would Like to Access the Camera/i,
+        acceptButtons: ["OK", "Allow"],
+    },
+    {
+        id: "microphone",
+        titlePattern: /Would Like to Access the Microphone/i,
+        acceptButtons: ["OK", "Allow"],
+    },
+    {
+        id: "photos",
+        titlePattern: /Would Like to Access Your Photos/i,
+        acceptButtons: [
+            "Allow Access to All Photos",
+            "Allow Full Access",
+            "Allow",
+        ],
+    },
+    {
+        id: "location",
+        titlePattern: /Allow .* to Use Your Location\??/i,
+        acceptButtons: [
+            "Allow While Using App",
+            "Allow Once",
+            "Allow",
+        ],
+    },
+    {
+        id: "notifications",
+        titlePattern: /Would Like to Send You Notifications/i,
+        acceptButtons: ["Allow"],
+    },
+    {
+        id: "local-network",
+        titlePattern: /Would Like to Find and Connect to Devices on Your Local Network/i,
+        acceptButtons: ["Allow", "OK"],
+    },
+    {
+        id: "bluetooth",
+        titlePattern: /Would Like to Use Bluetooth/i,
+        acceptButtons: ["OK", "Allow"],
+    },
+    {
+        id: "tracking",
+        titlePattern: /Allow .* to track your activity|would like permission to track/i,
+        acceptButtons: ["Allow"],
+    },
+    {
+        id: "faceid",
+        titlePattern: /Would Like to Use Face ID/i,
+        acceptButtons: ["OK", "Allow"],
+    },
+];
+const ALERT_TYPE_PATTERNS = [
+    /XCUIElementTypeAlert/i,
+    /SBAlertController/i,
+];
+function isAlertElement(el) {
+    const type = String(el.type ?? "");
+    return ALERT_TYPE_PATTERNS.some((p) => p.test(type));
+}
+function findAlert(root) {
+    if (isAlertElement(root))
+        return root;
+    const children = root.children;
+    if (Array.isArray(children)) {
+        for (const child of children) {
+            const found = findAlert(child);
+            if (found)
+                return found;
+        }
+    }
+    return null;
+}
+function collectAlertContents(root) {
+    const texts = [];
+    const buttons = [];
+    const visit = (el) => {
+        const type = String(el.type ?? "");
+        const label = String(el.label ?? el.name ?? "");
+        const value = String(el.value ?? "");
+        if (/XCUIElementTypeStaticText/i.test(type)) {
+            const text = label || value;
+            if (text)
+                texts.push(text);
+        }
+        else if (/XCUIElementTypeButton/i.test(type)) {
+            if (label)
+                buttons.push({ label, element: el });
+        }
+        else if (!type) {
+        }
+        const children = el.children;
+        if (Array.isArray(children)) {
+            for (const child of children)
+                visit(child);
+        }
+    };
+    visit(root);
+    return { texts, buttons };
+}
+export class PermissionInterceptor {
+    screen;
+    mode;
+    onDialog;
+    constructor(opts) {
+        this.screen = opts.screen;
+        this.mode = opts.mode;
+        this.onDialog = opts.onDialog;
+    }
+    getMode() {
+        return this.mode;
+    }
+    setMode(mode) {
+        this.mode = mode;
+    }
+    async checkAndHandle() {
+        if (this.mode === "off") {
+            return { handled: false };
+        }
+        const src = await this.screen.getSource().catch(() => undefined);
+        if (!src?.success || !src.source) {
+            return { handled: false };
+        }
+        const alert = findAlert(src.source);
+        if (!alert)
+            return { handled: false };
+        const { texts, buttons } = collectAlertContents(alert);
+        if (texts.length === 0 && buttons.length === 0) {
+            return { handled: false };
+        }
+        const title = texts[0] ?? "";
+        const body = texts.slice(1).join(" ");
+        const pattern = KNOWN_DIALOGS.find((p) => p.titlePattern.test(title));
+        if (!pattern) {
+            return { handled: false };
+        }
+        let action = "accept";
+        if (this.mode === "ask") {
+            if (this.onDialog) {
+                try {
+                    action = await this.onDialog({ title, body });
+                }
+                catch {
+                    action = "accept";
+                }
+            }
+        }
+        const buttonLabels = action === "accept"
+            ? pattern.acceptButtons
+            : pattern.denyButtons ?? ["Don't Allow", "Cancel"];
+        const target = buttonLabels
+            .map((preferred) => buttons.find((b) => b.label.toLowerCase() === preferred.toLowerCase()))
+            .find((b) => !!b);
+        if (!target) {
+            return {
+                handled: false,
+                dialog: { title, body, action },
+            };
+        }
+        const tap = await this.screen.findAndTap({
+            accessibilityLabel: target.label,
+        });
+        if (!tap.success) {
+            return {
+                handled: false,
+                dialog: { title, body, action },
+            };
+        }
+        return {
+            handled: true,
+            dialog: { title, body, action },
+        };
+    }
+}
+export function modeFromEnv(value) {
+    const v = (value ?? "").toLowerCase();
+    if (v === "off" || v === "false" || v === "0")
+        return "off";
+    if (v === "ask")
+        return "ask";
+    return "auto-accept";
+}

package/dist/prebuild-detector.d.ts

@@ -1,8 +1,3 @@
-/**
- * Detects when a clean Expo prebuild is needed by comparing
- * current project state against a cached snapshot from the last
- * successful build.
- */
 interface PrebuildCheckResult {
     needsClean: boolean;
     reasons: string[];
@@ -12,38 +7,13 @@ export declare class PrebuildDetector {
     private projectDir;
     private snapshotPath;
     constructor(projectDir: string, cacheDir: string);
-    /**
-     * Check if a file exists.
-     */
     private fileExists;
-    /**
-     * Read and parse a JSON file, returning null if it doesn't exist or is invalid.
-     */
     private readJson;
-    /**
-     * Compute a simple hash of a file's contents for change detection.
-     * Uses a basic string hash rather than crypto to keep it lightweight.
-     */
     private hashFile;
-    /**
-     * Read the current project state for snapshot comparison.
-     */
     private getCurrentState;
-    /**
-     * Load the cached snapshot from the last successful build.
-     */
     private loadSnapshot;
-    /**
-     * Save a snapshot after a successful build.
-     */
     saveSnapshot(): Promise<void>;
-    /**
-     * Diff two dependency maps and return lists of added, removed, and changed entries.
-     */
     private diffDependencies;
-    /**
-     * Check whether a clean prebuild is likely needed.
-     */
     check(): Promise<PrebuildCheckResult>;
 }
 export {};

package/dist/prebuild-detector.js

@@ -1,8 +1,3 @@
-/**
- * Detects when a clean Expo prebuild is needed by comparing
- * current project state against a cached snapshot from the last
- * successful build.
- */
 import { readFile, writeFile, mkdir, access } from "node:fs/promises";
 import { join } from "node:path";
 export class PrebuildDetector {
@@ -14,9 +9,6 @@ export class PrebuildDetector {
         this.cacheDir = cacheDir;
         this.snapshotPath = join(cacheDir, "last-build-snapshot.json");
     }
-    /**
-     * Check if a file exists.
-     */
     async fileExists(path) {
         try {
             await access(path);
@@ -26,9 +18,6 @@ export class PrebuildDetector {
             return false;
         }
     }
-    /**
-     * Read and parse a JSON file, returning null if it doesn't exist or is invalid.
-     */
     async readJson(path) {
         try {
             const content = await readFile(path, "utf-8");
@@ -38,10 +27,6 @@ export class PrebuildDetector {
             return null;
         }
     }
-    /**
-     * Compute a simple hash of a file's contents for change detection.
-     * Uses a basic string hash rather than crypto to keep it lightweight.
-     */
     async hashFile(path) {
         try {
             const content = await readFile(path, "utf-8");
@@ -49,7 +34,7 @@ export class PrebuildDetector {
             for (let i = 0; i < content.length; i++) {
                 const chr = content.charCodeAt(i);
                 hash = (hash << 5) - hash + chr;
-                hash |= 0; // Convert to 32-bit integer
+                hash |= 0;
             }
             return hash.toString(36);
         }
@@ -57,15 +42,10 @@ export class PrebuildDetector {
             return "missing";
         }
     }
-    /**
-     * Read the current project state for snapshot comparison.
-     */
     async getCurrentState() {
         const pkgJson = await this.readJson(join(this.projectDir, "package.json"));
-        // Try app.json first, fall back to app.config.js/ts content
         let appConfig = await this.readJson(join(this.projectDir, "app.json"));
         if (!appConfig) {
-            // For app.config.js/ts, we just hash the file instead of evaluating it
             const configHash = await this.hashFile(join(this.projectDir, "app.config.js"));
             const configTsHash = await this.hashFile(join(this.projectDir, "app.config.ts"));
             appConfig = {
@@ -82,9 +62,6 @@ export class PrebuildDetector {
             timestamp: new Date().toISOString(),
         };
     }
-    /**
-     * Load the cached snapshot from the last successful build.
-     */
     async loadSnapshot() {
         try {
             const content = await readFile(this.snapshotPath, "utf-8");
@@ -94,18 +71,11 @@ export class PrebuildDetector {
             return null;
         }
     }
-    /**
-     * Save a snapshot after a successful build.
-     */
     async saveSnapshot() {
         const state = await this.getCurrentState();
-        // Ensure cache directory exists
         await mkdir(this.cacheDir, { recursive: true });
         await writeFile(this.snapshotPath, JSON.stringify(state, null, 2), "utf-8");
     }
-    /**
-     * Diff two dependency maps and return lists of added, removed, and changed entries.
-     */
     diffDependencies(oldDeps, newDeps) {
         const added = [];
         const removed = [];
@@ -127,12 +97,8 @@ export class PrebuildDetector {
         }
         return { added, removed, changed };
     }
-    /**
-     * Check whether a clean prebuild is likely needed.
-     */
     async check() {
         const reasons = [];
-        // Check if ios/ directory exists at all
         const iosExists = await this.fileExists(join(this.projectDir, "ios"));
         if (!iosExists) {
             return {
@@ -142,7 +108,6 @@ export class PrebuildDetector {
                 ],
             };
         }
-        // Load the last build snapshot
         const snapshot = await this.loadSnapshot();
         if (!snapshot) {
             return {
@@ -153,9 +118,7 @@ export class PrebuildDetector {
                 ],
             };
         }
-        // Get current state
         const current = await this.getCurrentState();
-        // Compare dependencies
         const depDiff = this.diffDependencies(snapshot.dependencies, current.dependencies);
         if (depDiff.added.length > 0) {
             reasons.push(`New dependencies added: ${depDiff.added.join(", ")}. ` +
@@ -166,7 +129,6 @@ export class PrebuildDetector {
                 "Stale native modules may cause build errors.");
         }
         if (depDiff.changed.length > 0) {
-            // Only flag native-related version changes as needing clean prebuild
             const nativeIndicators = [
                 "react-native",
                 "expo",
@@ -179,7 +141,6 @@ export class PrebuildDetector {
                     "Clean prebuild recommended.");
             }
         }
-        // Compare devDependencies
         const devDepDiff = this.diffDependencies(snapshot.devDependencies, current.devDependencies);
         if (devDepDiff.added.length > 0 || devDepDiff.removed.length > 0) {
             const nativeDevDeps = [
@@ -192,14 +153,12 @@ export class PrebuildDetector {
                 reasons.push(`Native dev dependencies changed: ${nativeDevDeps.join(", ")}.`);
             }
         }
-        // Compare app config
         const configChanged = JSON.stringify(snapshot.appConfig) !==
             JSON.stringify(current.appConfig);
         if (configChanged) {
             reasons.push("app.json / app.config.js has changed since last build. " +
                 "Expo plugins or native config may have changed.");
         }
-        // Compare Podfile.lock hash
         if (current.podfileLockHash === "missing") {
             reasons.push("ios/Podfile.lock is missing. Pods may need to be installed.");
         }