@ceraph/react-native-mcp 0.3.3 → 0.4.5

package/dist/expo-manager.js

@@ -1,447 +0,0 @@
-import { spawn } from "node:child_process";
-import { writeFile, access } from "node:fs/promises";
-import { join } from "node:path";
-import { parseBuildOutput, parseMetroOutput, MetroErrorParser, classifyLogLevel, } from "./error-parser.js";
-export class RNManager {
-    buildProcess = null;
-    metroProcess = null;
-    buildKilled = false;
-    metroKilled = false;
-    buildOutput = [];
-    metroOutput = [];
-    buildErrors = [];
-    runtimeErrors = [];
-    buildWarnings = [];
-    metroWarnings = [];
-    metroParser = new MetroErrorParser();
-    MAX_BUILD_LINES = 1000;
-    MAX_METRO_LINES = 500;
-    MAX_ERRORS = 100;
-    cwd;
-    errorFilePath;
-    constructor(cwd) {
-        this.cwd = cwd;
-        this.errorFilePath = join(cwd, ".rn-errors.json");
-    }
-    async detectProjectType() {
-        try {
-            const appJsonPath = join(this.cwd, "app.json");
-            await access(appJsonPath);
-            const appJson = JSON.parse(await (await import("node:fs/promises")).readFile(appJsonPath, "utf-8"));
-            if (appJson.expo) {
-                return true;
-            }
-        }
-        catch {
-        }
-        try {
-            const pkgPath = join(this.cwd, "package.json");
-            const pkg = JSON.parse(await (await import("node:fs/promises")).readFile(pkgPath, "utf-8"));
-            if (pkg.dependencies?.expo) {
-                return true;
-            }
-        }
-        catch {
-        }
-        return false;
-    }
-    async writeErrorFile(errors) {
-        try {
-            await writeFile(this.errorFilePath, JSON.stringify({
-                timestamp: new Date().toISOString(),
-                errors: errors.map((e) => ({
-                    message: e.message,
-                    stack: e.stack,
-                    timestamp: e.timestamp,
-                    kind: e.kind ?? "metro-error",
-                    ...(e.url !== undefined ? { url: e.url } : {}),
-                    ...(e.status !== undefined ? { status: e.status } : {}),
-                    ...(e.method !== undefined ? { method: e.method } : {}),
-                    ...(e.durationMs !== undefined ? { durationMs: e.durationMs } : {}),
-                })),
-            }, null, 2), "utf-8");
-        }
-        catch {
-        }
-    }
-    async appendShimSignal(entry) {
-        this.runtimeErrors.push(entry);
-        this.capErrors(this.runtimeErrors);
-        await this.writeErrorFile(this.runtimeErrors);
-    }
-    async clearErrorFile() {
-        try {
-            await writeFile(this.errorFilePath, JSON.stringify({ timestamp: new Date().toISOString(), errors: [] }), "utf-8");
-        }
-        catch {
-        }
-    }
-    pushLine(buffer, line, max) {
-        buffer.push(line);
-        if (buffer.length > max) {
-            buffer.splice(0, buffer.length - max);
-        }
-    }
-    capErrors(arr) {
-        if (arr.length > this.MAX_ERRORS) {
-            arr.splice(0, arr.length - this.MAX_ERRORS);
-        }
-    }
-    async killProcess(proc) {
-        return new Promise((resolve) => {
-            if (!proc.pid || proc.exitCode !== null) {
-                resolve();
-                return;
-            }
-            let hardTimer = null;
-            const softTimer = setTimeout(() => {
-                try {
-                    proc.kill("SIGKILL");
-                }
-                catch {
-                }
-                hardTimer = setTimeout(() => {
-                    proc.off("exit", onExit);
-                    resolve();
-                }, 2000);
-            }, 5000);
-            const onExit = () => {
-                clearTimeout(softTimer);
-                if (hardTimer)
-                    clearTimeout(hardTimer);
-                resolve();
-            };
-            proc.once("exit", onExit);
-            try {
-                proc.kill("SIGTERM");
-            }
-            catch {
-                proc.off("exit", onExit);
-                clearTimeout(softTimer);
-                resolve();
-                return;
-            }
-            if (proc.exitCode !== null) {
-                proc.off("exit", onExit);
-                clearTimeout(softTimer);
-                resolve();
-            }
-        });
-    }
-    runPrebuildClean() {
-        return new Promise((resolve) => {
-            const lines = [];
-            const proc = spawn("npx", ["expo", "prebuild", "--clean"], {
-                cwd: this.cwd,
-                stdio: ["ignore", "pipe", "pipe"],
-            });
-            const onData = (data) => {
-                const text = data.toString();
-                for (const line of text.split("\n")) {
-                    if (line.trim())
-                        lines.push(line);
-                }
-            };
-            proc.stdout?.on("data", onData);
-            proc.stderr?.on("data", onData);
-            let resolved = false;
-            proc.on("error", (err) => {
-                if (resolved)
-                    return;
-                resolved = true;
-                resolve({
-                    success: false,
-                    output: `Failed to spawn prebuild: ${err.message}`,
-                });
-            });
-            proc.on("exit", (code) => {
-                if (resolved)
-                    return;
-                resolved = true;
-                resolve({
-                    success: code === 0,
-                    output: lines.join("\n"),
-                });
-            });
-        });
-    }
-    async runBuild(options = {}) {
-        const isExpo = await this.detectProjectType();
-        if (this.buildProcess) {
-            this.buildKilled = true;
-            await this.killProcess(this.buildProcess);
-            this.buildProcess = null;
-        }
-        this.buildKilled = false;
-        this.buildOutput = [];
-        this.buildErrors = [];
-        this.buildWarnings = [];
-        if (options.clean) {
-            if (!isExpo) {
-                return {
-                    success: false,
-                    errors: [
-                        {
-                            file: "",
-                            line: 0,
-                            message: "prebuild --clean is only available for Expo projects.",
-                            type: "build",
-                        },
-                    ],
-                    warnings: [],
-                    output: "",
-                };
-            }
-            const prebuildResult = await this.runPrebuildClean();
-            if (!prebuildResult.success) {
-                return {
-                    success: false,
-                    errors: [
-                        {
-                            file: "",
-                            line: 0,
-                            message: `prebuild --clean failed:\n${prebuildResult.output}`,
-                            type: "build",
-                        },
-                    ],
-                    warnings: [],
-                    output: prebuildResult.output,
-                };
-            }
-            for (const line of prebuildResult.output.split("\n")) {
-                this.pushLine(this.buildOutput, line, this.MAX_BUILD_LINES);
-            }
-        }
-        const args = isExpo ? ["expo", "run:ios"] : ["react-native", "run-ios"];
-        if (options.device) {
-            args.push(isExpo ? "--device" : "--udid", options.device);
-        }
-        return new Promise((resolve) => {
-            const proc = spawn("npx", args, {
-                cwd: this.cwd,
-                stdio: ["ignore", "pipe", "pipe"],
-            });
-            this.buildProcess = proc;
-            const onData = (data) => {
-                const text = data.toString();
-                for (const line of text.split("\n")) {
-                    if (line.trim()) {
-                        this.pushLine(this.buildOutput, line, this.MAX_BUILD_LINES);
-                    }
-                }
-            };
-            proc.stdout?.on("data", onData);
-            proc.stderr?.on("data", onData);
-            let resolved = false;
-            proc.on("error", (err) => {
-                if (resolved)
-                    return;
-                resolved = true;
-                this.buildProcess = null;
-                resolve({
-                    success: false,
-                    errors: [
-                        {
-                            file: "",
-                            line: 0,
-                            message: `Failed to spawn ${isExpo ? "expo run:ios" : "react-native run-ios"}: ${err.message}`,
-                            type: "build",
-                        },
-                    ],
-                    warnings: [],
-                    output: this.buildOutput.join("\n"),
-                });
-            });
-            proc.on("exit", (code) => {
-                if (resolved)
-                    return;
-                resolved = true;
-                this.buildProcess = null;
-                if (this.buildKilled) {
-                    resolve({
-                        success: false,
-                        errors: [],
-                        warnings: [],
-                        output: "Build was cancelled.",
-                    });
-                    return;
-                }
-                const parsed = parseBuildOutput(this.buildOutput);
-                this.buildErrors = parsed.errors;
-                this.buildWarnings = parsed.warnings;
-                this.capErrors(this.buildErrors);
-                const success = code === 0 && !parsed.buildFailed;
-                resolve({
-                    success,
-                    errors: parsed.errors.map((e) => ({
-                        file: e.file,
-                        line: e.line,
-                        message: e.message,
-                        type: e.type,
-                    })),
-                    warnings: parsed.warnings,
-                    output: this.buildOutput.slice(-100).join("\n"),
-                });
-            });
-        });
-    }
-    async startMetro(options = {}) {
-        const isExpo = await this.detectProjectType();
-        if (this.metroProcess) {
-            this.metroKilled = true;
-            await this.killProcess(this.metroProcess);
-            this.metroProcess = null;
-        }
-        this.metroKilled = false;
-        this.metroOutput = [];
-        this.runtimeErrors = [];
-        this.metroWarnings = [];
-        this.metroParser = new MetroErrorParser();
-        const args = isExpo
-            ? ["expo", "start", "--dev-client"]
-            : ["react-native", "start"];
-        if (options.port) {
-            args.push("--port", String(options.port));
-        }
-        if (options.clear) {
-            args.push(isExpo ? "--clear" : "--reset-cache");
-        }
-        await this.clearErrorFile();
-        return new Promise((resolve) => {
-            const proc = spawn("npx", args, {
-                cwd: this.cwd,
-                stdio: ["ignore", "pipe", "pipe"],
-            });
-            this.metroProcess = proc;
-            let resolved = false;
-            const onData = (data) => {
-                const text = data.toString();
-                const chunkLines = [];
-                for (const line of text.split("\n")) {
-                    if (line.trim()) {
-                        this.pushLine(this.metroOutput, line, this.MAX_METRO_LINES);
-                        chunkLines.push(line);
-                    }
-                }
-                if (chunkLines.length > 0) {
-                    const parsed = this.metroParser.parse(chunkLines);
-                    if (parsed.runtimeErrors.length > 0) {
-                        this.runtimeErrors.push(...parsed.runtimeErrors);
-                        this.capErrors(this.runtimeErrors);
-                        this.writeErrorFile(this.runtimeErrors);
-                    }
-                    if (parsed.warnings.length > 0) {
-                        this.metroWarnings.push(...parsed.warnings);
-                    }
-                }
-                if (!resolved && text.includes("Metro waiting on")) {
-                    resolved = true;
-                    resolve({
-                        success: true,
-                        message: "Metro dev server started successfully.",
-                    });
-                }
-            };
-            proc.stdout?.on("data", onData);
-            proc.stderr?.on("data", onData);
-            proc.on("error", (err) => {
-                this.metroProcess = null;
-                if (!resolved) {
-                    resolved = true;
-                    resolve({
-                        success: false,
-                        message: `Failed to start Metro: ${err.message}`,
-                    });
-                }
-            });
-            proc.on("exit", (code) => {
-                this.metroProcess = null;
-                const flushed = this.metroParser.flush();
-                if (flushed.runtimeErrors.length > 0) {
-                    this.runtimeErrors.push(...flushed.runtimeErrors);
-                    this.capErrors(this.runtimeErrors);
-                    this.writeErrorFile(this.runtimeErrors);
-                }
-                if (this.metroKilled) {
-                    if (!resolved) {
-                        resolved = true;
-                        resolve({
-                            success: false,
-                            message: "Metro was cancelled.",
-                        });
-                    }
-                    return;
-                }
-                if (!resolved) {
-                    resolved = true;
-                    resolve({
-                        success: false,
-                        message: `Metro exited unexpectedly with code ${code}.`,
-                    });
-                }
-            });
-            setTimeout(() => {
-                if (!resolved) {
-                    resolved = true;
-                    resolve({
-                        success: true,
-                        message: "Metro process started but has not confirmed readiness yet. " +
-                            "It may still be initializing. Use rn_get_console to check.",
-                    });
-                }
-            }, 30_000);
-        });
-    }
-    getErrors() {
-        const metroParsed = this.metroProcess === null
-            ? parseMetroOutput(this.metroOutput)
-            : { runtimeErrors: [], warnings: [] };
-        return {
-            buildErrors: this.buildErrors.map((e) => ({
-                file: e.file,
-                line: e.line,
-                column: e.column,
-                message: e.message,
-                severity: e.severity,
-                type: e.type,
-            })),
-            runtimeErrors: this.runtimeErrors.length > 0
-                ? this.runtimeErrors
-                : metroParsed.runtimeErrors,
-            warnings: [...this.buildWarnings, ...this.metroWarnings],
-        };
-    }
-    getConsole(options = {}) {
-        const { lines = 50, level = "all" } = options;
-        let output = this.metroOutput;
-        if (level !== "all") {
-            output = output.filter((line) => {
-                const classified = classifyLogLevel(line);
-                return classified === level;
-            });
-        }
-        return output.slice(-lines);
-    }
-    async stopAll() {
-        const stopped = [];
-        if (this.buildProcess) {
-            this.buildKilled = true;
-            await this.killProcess(this.buildProcess);
-            this.buildProcess = null;
-            stopped.push("build");
-        }
-        if (this.metroProcess) {
-            this.metroKilled = true;
-            await this.killProcess(this.metroProcess);
-            this.metroProcess = null;
-            stopped.push("metro");
-        }
-        return stopped;
-    }
-    getBuildOutput() {
-        return [...this.buildOutput];
-    }
-    getMetroOutput() {
-        return [...this.metroOutput];
-    }
-}

package/dist/init/ast-camera.d.ts

@@ -1,29 +0,0 @@
-export interface CameraReplacementEdit {
-    filePath: string;
-    relPath: string;
-    line: number;
-    suggestedKey: string;
-    alreadyHasImageKey: boolean;
-}
-export interface ScanCameraViewsResult {
-    edits: CameraReplacementEdit[];
-    filesScanned: number;
-}
-export declare function suggestImageKey(absPath: string): string;
-export declare function scanCameraViews(projectDir: string): Promise<ScanCameraViewsResult>;
-export interface ApplyEditsResult {
-    filesEdited: string[];
-    totalReplacements: number;
-}
-export interface ApplyEditsOptions {
-    omitImageKey?: boolean;
-}
-export declare function applyCameraEdits(projectDir: string, edits: CameraReplacementEdit[], options?: ApplyEditsOptions): Promise<ApplyEditsResult>;
-export interface SetImageKeyResult {
-    applied: boolean;
-    previousValue?: string | null;
-    reason?: string;
-}
-export declare function setImageKeyOnExistingTag(filePath: string, line: number, imageKey: string): Promise<SetImageKeyResult>;
-export declare function snapshotFile(filePath: string): Promise<string | null>;
-export declare function restoreFile(filePath: string, snapshot: string): Promise<void>;