@ceraph/react-native-mcp 0.2.0

package/dist/prebuild-detector.d.ts

@@ -0,0 +1,49 @@
+/**
+ * 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[];
+}
+export declare class PrebuildDetector {
+    private cacheDir;
+    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

@@ -0,0 +1,215 @@
+/**
+ * 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 {
+    cacheDir;
+    projectDir;
+    snapshotPath;
+    constructor(projectDir, cacheDir) {
+        this.projectDir = projectDir;
+        this.cacheDir = cacheDir;
+        this.snapshotPath = join(cacheDir, "last-build-snapshot.json");
+    }
+    /**
+     * Check if a file exists.
+     */
+    async fileExists(path) {
+        try {
+            await access(path);
+            return true;
+        }
+        catch {
+            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");
+            return JSON.parse(content);
+        }
+        catch {
+            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");
+            let hash = 0;
+            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
+            }
+            return hash.toString(36);
+        }
+        catch {
+            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 = {
+                _fileHash: configHash,
+                _tsFileHash: configTsHash,
+            };
+        }
+        const podfileLockHash = await this.hashFile(join(this.projectDir, "ios", "Podfile.lock"));
+        return {
+            dependencies: (pkgJson?.dependencies ?? {}),
+            devDependencies: (pkgJson?.devDependencies ?? {}),
+            appConfig: appConfig ?? {},
+            podfileLockHash,
+            timestamp: new Date().toISOString(),
+        };
+    }
+    /**
+     * Load the cached snapshot from the last successful build.
+     */
+    async loadSnapshot() {
+        try {
+            const content = await readFile(this.snapshotPath, "utf-8");
+            return JSON.parse(content);
+        }
+        catch {
+            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 = [];
+        const changed = [];
+        const allKeys = new Set([
+            ...Object.keys(oldDeps),
+            ...Object.keys(newDeps),
+        ]);
+        for (const key of allKeys) {
+            if (!(key in oldDeps)) {
+                added.push(key);
+            }
+            else if (!(key in newDeps)) {
+                removed.push(key);
+            }
+            else if (oldDeps[key] !== newDeps[key]) {
+                changed.push(key);
+            }
+        }
+        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 {
+                needsClean: true,
+                reasons: [
+                    "ios/ directory does not exist. Run `npx expo prebuild` to generate native projects.",
+                ],
+            };
+        }
+        // Load the last build snapshot
+        const snapshot = await this.loadSnapshot();
+        if (!snapshot) {
+            return {
+                needsClean: true,
+                reasons: [
+                    "No previous build snapshot found. Run a build to establish a baseline. " +
+                        "A clean prebuild is recommended for the first build.",
+                ],
+            };
+        }
+        // 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(", ")}. ` +
+                "Native modules may need linking.");
+        }
+        if (depDiff.removed.length > 0) {
+            reasons.push(`Dependencies removed: ${depDiff.removed.join(", ")}. ` +
+                "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",
+                "@react-native",
+                "react-native-",
+            ];
+            const nativeChanges = depDiff.changed.filter((dep) => nativeIndicators.some((indicator) => dep.includes(indicator)));
+            if (nativeChanges.length > 0) {
+                reasons.push(`Native dependency versions changed: ${nativeChanges.join(", ")}. ` +
+                    "Clean prebuild recommended.");
+            }
+        }
+        // Compare devDependencies
+        const devDepDiff = this.diffDependencies(snapshot.devDependencies, current.devDependencies);
+        if (devDepDiff.added.length > 0 || devDepDiff.removed.length > 0) {
+            const nativeDevDeps = [
+                ...devDepDiff.added,
+                ...devDepDiff.removed,
+            ].filter((dep) => dep.includes("react-native") ||
+                dep.includes("expo") ||
+                dep.includes("@react-native"));
+            if (nativeDevDeps.length > 0) {
+                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.");
+        }
+        else if (snapshot.podfileLockHash !== current.podfileLockHash) {
+            reasons.push("ios/Podfile.lock has changed since last build. " +
+                "Pod dependencies may be out of sync.");
+        }
+        return {
+            needsClean: reasons.length > 0,
+            reasons,
+        };
+    }
+}

package/dist/screen.d.ts

@@ -0,0 +1,95 @@
+/**
+ * WebDriverAgent client with pixel ratio correction.
+ *
+ * Talks to the WDA HTTP server running on localhost:8100 to perform
+ * taps and element lookups on a connected iOS device.
+ */
+export interface TapResult {
+    success: boolean;
+    tappedAt: {
+        x: number;
+        y: number;
+    };
+    pixelRatio: number;
+    correction: string;
+    error?: string;
+}
+export interface ElementInfo {
+    type: string;
+    label: string;
+    bounds: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+export interface FindTapResult {
+    success: boolean;
+    element?: ElementInfo;
+    tappedAt?: {
+        x: number;
+        y: number;
+    };
+    availableElements?: Array<{
+        type: string;
+        label: string;
+        text: string;
+    }>;
+    error?: string;
+}
+interface ElementQuery {
+    text?: string;
+    accessibilityLabel?: string;
+    type?: string;
+    index?: number;
+}
+export declare class ScreenManager {
+    private sessionId;
+    private pixelRatio;
+    /**
+     * Check whether WebDriverAgent is reachable.
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * Get or create a WDA session. Sessions are cached and revalidated.
+     */
+    ensureSession(): Promise<string>;
+    /**
+     * Determine the pixel ratio between screenshot coordinates and
+     * device logical coordinates.
+     *
+     * Screenshot images are in physical pixels; WDA taps use logical points.
+     * The ratio is typically 2 (for @2x Retina) or 3 (for @3x).
+     */
+    getPixelRatio(): Promise<number>;
+    /**
+     * Tap at the given coordinates.
+     *
+     * When `fromScreenshot` is true (the default), the coordinates are
+     * assumed to come from a screenshot image and are divided by the
+     * pixel ratio to convert to logical device points.
+     */
+    tap(x: number, y: number, fromScreenshot?: boolean): Promise<TapResult>;
+    /**
+     * Find an element in the UI tree and tap its center.
+     */
+    findAndTap(query: ElementQuery): Promise<FindTapResult>;
+    /**
+     * Recursively search the WDA element tree for elements matching the query.
+     */
+    private searchElements;
+    /**
+     * Check whether a single element matches the given query.
+     */
+    private elementMatches;
+    /**
+     * Collect a summary of visible elements for debugging (when no match found).
+     */
+    private collectVisibleElements;
+    /**
+     * Invalidate cached session and pixel ratio (e.g., after app restart).
+     */
+    reset(): void;
+}
+export {};