@ceraph/react-native-mcp 0.2.2 → 0.3.2

package/dist/error-parser.d.ts

@@ -1,7 +1,3 @@
-/**
- * Parses Xcode build errors, Metro bundler errors, and runtime errors
- * from raw process output.
- */
 export interface BuildError {
     file: string;
     line: number;
@@ -10,10 +6,16 @@ export interface BuildError {
     severity: "error" | "warning" | "note";
     type: "build" | "link" | "pod";
 }
+export type RuntimeSignalKind = "metro-error" | "js-error" | "unhandled-rejection" | "network-error" | "network-4xx";
 export interface RuntimeError {
     message: string;
     stack: string;
     timestamp: string;
+    kind?: RuntimeSignalKind;
+    url?: string;
+    status?: number;
+    method?: string;
+    durationMs?: number;
 }
 export interface Warning {
     message: string;
@@ -24,21 +26,11 @@ export interface AllErrors {
     runtimeErrors: RuntimeError[];
     warnings: Warning[];
 }
-/**
- * Parse all build output lines and extract structured errors.
- */
 export declare function parseBuildOutput(lines: string[]): {
     errors: BuildError[];
     warnings: Warning[];
     buildFailed: boolean;
 };
-/**
- * Stateful parser for Metro output. Multi-line errors (message + stack
- * trace) arrive across multiple `onData` chunks, so the in-progress
- * error must persist across calls. Use one instance per Metro session
- * and call `parse(lines)` as chunks arrive; call `flush()` at the end
- * (e.g. on process exit) to emit any error still being assembled.
- */
 export declare class MetroErrorParser {
     private currentStack;
     private currentErrorMessage;
@@ -47,25 +39,13 @@ export declare class MetroErrorParser {
         runtimeErrors: RuntimeError[];
         warnings: Warning[];
     };
-    /**
-     * Force-emit any error currently being assembled. Call on stream end.
-     */
     flush(): {
         runtimeErrors: RuntimeError[];
         warnings: Warning[];
     };
 }
-/**
- * Parse a complete Metro buffer in one shot. Suitable for batch use
- * (e.g. `getErrors()` re-parsing the rolling buffer); for streaming use
- * a `MetroErrorParser` instance instead so multi-line state survives
- * across chunks.
- */
 export declare function parseMetroOutput(lines: string[]): {
     runtimeErrors: RuntimeError[];
     warnings: Warning[];
 };
-/**
- * Classify a log line by level.
- */
 export declare function classifyLogLevel(line: string): "error" | "warn" | "log";

package/dist/error-parser.js

@@ -1,33 +1,20 @@
-/**
- * Parses Xcode build errors, Metro bundler errors, and runtime errors
- * from raw process output.
- */
-// Xcode-style: /path/to/File.swift:12:5: error: something went wrong
 const XCODE_ERROR_RE = /^(.+?):(\d+):(\d+):\s*(error|warning|note):\s*(.+)$/;
-// Xcode build failure markers
 const BUILD_FAILED_MARKERS = [
     "Build Failed",
     "** BUILD FAILED **",
     "xcodebuild: error:",
     "❌",
 ];
-// Linker errors
 const LINKER_ERROR_RE = /^(ld|clang):\s*(error|warning):\s*(.+)$/;
 const UNDEFINED_SYMBOL_RE = /^Undefined symbols? for architecture .+:\s*"(.+)"/;
-// CocoaPods errors
 const POD_ERROR_RE = /^\[!\]\s*(.+)$/;
-// Metro bundler errors
 const METRO_ERROR_RE = /^(Error|TypeError|ReferenceError|SyntaxError|RangeError):\s*(.+)$/;
 const METRO_MODULE_RE = /Unable to resolve module ['"](.+?)['"]/;
 const METRO_ENCOUNTERED_RE = /Metro has encountered an error/;
-// Runtime errors from console
 const CONSOLE_ERROR_RE = /^(ERROR|console\.error)\s*(.+)$/i;
 const INVARIANT_RE = /Invariant Violation:\s*(.+)/;
 const UNHANDLED_JS_RE = /Unhandled JS Exception:\s*(.+)/;
 const RED_SCREEN_RE = /ExceptionsManager\.js/;
-/**
- * Parse a single line for Xcode build errors/warnings.
- */
 function parseXcodeLine(line) {
     const match = line.match(XCODE_ERROR_RE);
     if (match) {
@@ -42,9 +29,6 @@ function parseXcodeLine(line) {
     }
     return null;
 }
-/**
- * Parse a single line for linker errors.
- */
 function parseLinkerLine(line) {
     const linkerMatch = line.match(LINKER_ERROR_RE);
     if (linkerMatch) {
@@ -70,17 +54,6 @@ function parseLinkerLine(line) {
     }
     return null;
 }
-/**
- * Parse a single line for CocoaPods notices.
- *
- * CocoaPods uses the `[!]` prefix for both errors and warnings. Default
- * to `error` and only downgrade when the message matches a known-safe
- * pattern (target overrides, deprecation hints, CDN/repo update notices,
- * advisory "should" / "recommends" copy). This is closed under unknown
- * failure modes — a new pod error vocabulary stays classified as an error
- * rather than silently becoming a warning that lets a broken build
- * resolve as success.
- */
 const POD_SAFE_WARNING_RE = /\b(cdn|trunk|repo update|overrides the|setting defined in|deprecated|recommends|should)\b/i;
 function parsePodLine(line) {
     const match = line.match(POD_ERROR_RE);
@@ -97,16 +70,10 @@ function parsePodLine(line) {
         type: "pod",
     };
 }
-/**
- * Parse all build output lines and extract structured errors.
- */
 export function parseBuildOutput(lines) {
     const errors = [];
     const warnings = [];
     let buildFailed = false;
-    // Track multi-line error context: sometimes Xcode emits the error
-    // on one line and the source context on the next few lines.
-    // We append context to the last error's message.
     let lastError = null;
     let contextLines = 0;
     const MAX_CONTEXT = 3;
@@ -117,11 +84,9 @@ export function parseBuildOutput(lines) {
             contextLines = 0;
             continue;
         }
-        // Check for build failure markers
         if (BUILD_FAILED_MARKERS.some((m) => trimmed.includes(m))) {
             buildFailed = true;
         }
-        // Try Xcode error format
         const xcodeError = parseXcodeLine(trimmed);
         if (xcodeError) {
             if (xcodeError.severity === "error") {
@@ -134,11 +99,9 @@ export function parseBuildOutput(lines) {
                     message: xcodeError.message,
                     source: `${xcodeError.file}:${xcodeError.line}:${xcodeError.column}`,
                 });
-                // Don't set lastError for warnings/notes
             }
             continue;
         }
-        // Try linker error format
         const linkerError = parseLinkerLine(trimmed);
         if (linkerError) {
             if (linkerError.severity === "warning") {
@@ -151,7 +114,6 @@ export function parseBuildOutput(lines) {
             contextLines = 0;
             continue;
         }
-        // Try CocoaPods notice format (warning or error depending on message)
         const podNotice = parsePodLine(trimmed);
         if (podNotice) {
             if (podNotice.severity === "warning") {
@@ -164,7 +126,6 @@ export function parseBuildOutput(lines) {
             }
             continue;
         }
-        // Append context lines to last error for multi-line messages
         if (lastError && contextLines < MAX_CONTEXT) {
             lastError.message += `\n${trimmed}`;
             contextLines++;
@@ -172,13 +133,6 @@ export function parseBuildOutput(lines) {
     }
     return { errors, warnings, buildFailed };
 }
-/**
- * Stateful parser for Metro output. Multi-line errors (message + stack
- * trace) arrive across multiple `onData` chunks, so the in-progress
- * error must persist across calls. Use one instance per Metro session
- * and call `parse(lines)` as chunks arrive; call `flush()` at the end
- * (e.g. on process exit) to emit any error still being assembled.
- */
 export class MetroErrorParser {
     currentStack = [];
     currentErrorMessage = "";
@@ -192,6 +146,7 @@ export class MetroErrorParser {
                     message: this.currentErrorMessage,
                     stack: this.currentStack.join("\n"),
                     timestamp: new Date().toISOString(),
+                    kind: "metro-error",
                 });
                 this.currentErrorMessage = "";
                 this.currentStack = [];
@@ -200,7 +155,6 @@ export class MetroErrorParser {
         };
         for (const line of lines) {
             const trimmed = line.trim();
-            // Metro module resolution errors — single-line, emit immediately.
             const moduleMatch = trimmed.match(METRO_MODULE_RE);
             if (moduleMatch) {
                 flushInto(runtimeErrors);
@@ -208,17 +162,16 @@ export class MetroErrorParser {
                     message: `Unable to resolve module '${moduleMatch[1]}'`,
                     stack: trimmed,
                     timestamp: new Date().toISOString(),
+                    kind: "metro-error",
                 });
                 continue;
             }
-            // Metro encountered an error
             if (METRO_ENCOUNTERED_RE.test(trimmed)) {
                 flushInto(runtimeErrors);
                 this.currentErrorMessage = "Metro has encountered an error";
                 this.inStackTrace = true;
                 continue;
             }
-            // Invariant Violation
             const invariantMatch = trimmed.match(INVARIANT_RE);
             if (invariantMatch) {
                 flushInto(runtimeErrors);
@@ -226,7 +179,6 @@ export class MetroErrorParser {
                 this.inStackTrace = true;
                 continue;
             }
-            // Unhandled JS Exception
             const unhandledMatch = trimmed.match(UNHANDLED_JS_RE);
             if (unhandledMatch) {
                 flushInto(runtimeErrors);
@@ -234,7 +186,6 @@ export class MetroErrorParser {
                 this.inStackTrace = true;
                 continue;
             }
-            // JS error types
             const metroMatch = trimmed.match(METRO_ERROR_RE);
             if (metroMatch) {
                 flushInto(runtimeErrors);
@@ -242,7 +193,6 @@ export class MetroErrorParser {
                 this.inStackTrace = true;
                 continue;
             }
-            // Console errors
             const consoleMatch = trimmed.match(CONSOLE_ERROR_RE);
             if (consoleMatch) {
                 flushInto(runtimeErrors);
@@ -250,20 +200,17 @@ export class MetroErrorParser {
                 this.inStackTrace = true;
                 continue;
             }
-            // Red screen detection
             if (RED_SCREEN_RE.test(trimmed)) {
                 if (!this.currentErrorMessage) {
                     this.currentErrorMessage = "Red screen error detected";
                 }
                 this.inStackTrace = true;
             }
-            // Stack trace lines (indented, or starting with "at ")
             if (this.inStackTrace) {
                 if (trimmed.startsWith("at ") ||
                     trimmed.startsWith("in ") ||
                     /^\s+at\s/.test(line) ||
-                    /^\d+\s*\|/.test(trimmed) // source code context lines
-                ) {
+                    /^\d+\s*\|/.test(trimmed)) {
                     this.currentStack.push(trimmed);
                     continue;
                 }
@@ -272,14 +219,10 @@ export class MetroErrorParser {
                     continue;
                 }
                 else {
-                    // Continuation of the error message. Skip the warning check —
-                    // a `warn ...` line interleaved with a stack trace would
-                    // otherwise be double-counted as both stack and warning.
                     this.currentStack.push(trimmed);
                     continue;
                 }
             }
-            // Warnings from Metro
             if (/^warn\s/i.test(trimmed) || /\(WARN\)/.test(trimmed)) {
                 warnings.push({
                     message: trimmed.replace(/^warn\s*/i, "").replace(/\(WARN\)\s*/, ""),
@@ -287,13 +230,8 @@ export class MetroErrorParser {
                 });
             }
         }
-        // Do NOT flush at end of chunk — the in-progress error may continue
-        // in the next chunk. Caller must invoke `flush()` when the stream ends.
         return { runtimeErrors, warnings };
     }
-    /**
-     * Force-emit any error currently being assembled. Call on stream end.
-     */
     flush() {
         const runtimeErrors = [];
         if (this.currentErrorMessage) {
@@ -301,6 +239,7 @@ export class MetroErrorParser {
                 message: this.currentErrorMessage,
                 stack: this.currentStack.join("\n"),
                 timestamp: new Date().toISOString(),
+                kind: "metro-error",
             });
             this.currentErrorMessage = "";
             this.currentStack = [];
@@ -309,12 +248,6 @@ export class MetroErrorParser {
         return { runtimeErrors, warnings: [] };
     }
 }
-/**
- * Parse a complete Metro buffer in one shot. Suitable for batch use
- * (e.g. `getErrors()` re-parsing the rolling buffer); for streaming use
- * a `MetroErrorParser` instance instead so multi-line state survives
- * across chunks.
- */
 export function parseMetroOutput(lines) {
     const parser = new MetroErrorParser();
     const streamed = parser.parse(lines);
@@ -324,9 +257,6 @@ export function parseMetroOutput(lines) {
         warnings: [...streamed.warnings, ...flushed.warnings],
     };
 }
-/**
- * Classify a log line by level.
- */
 export function classifyLogLevel(line) {
     const trimmed = line.trim().toLowerCase();
     if (trimmed.startsWith("error") ||

package/dist/expo-manager.d.ts

@@ -1,10 +1,4 @@
-/**
- * Manages React Native / Expo child processes (build and Metro dev server).
- * Auto-detects whether the project uses Expo or bare React Native
- * and runs the appropriate commands.
- * Captures stdout/stderr into rolling buffers and parses errors.
- */
-import { type Warning, type AllErrors } from "./error-parser.js";
+import { type RuntimeError, type Warning, type AllErrors } from "./error-parser.js";
 export interface BuildResult {
     success: boolean;
     errors: Array<{
@@ -43,92 +37,26 @@ export declare class RNManager {
     private readonly MAX_BUILD_LINES;
     private readonly MAX_METRO_LINES;
     private readonly MAX_ERRORS;
-    /** The working directory for commands. */
     private cwd;
-    /** Path to the error file that triggers the Claude Code hook. */
     private errorFilePath;
     constructor(cwd: string);
-    /**
-     * Detect whether this is an Expo or bare React Native project.
-     * Checks for app.json with expo config or expo package in dependencies.
-     */
     detectProjectType(): Promise<boolean>;
-    /**
-     * Write errors to .rn-errors.json so the Claude Code hook can detect them.
-     * Overwrites the file each time — the hook fires on any write.
-     */
     private writeErrorFile;
-    /**
-     * Clear the error file (e.g., on successful build or process start).
-     */
+    appendShimSignal(entry: RuntimeError): Promise<void>;
     private clearErrorFile;
-    /**
-     * Append a line to a rolling buffer, evicting oldest entries when full.
-     */
     private pushLine;
-    /**
-     * Cap an error array at MAX_ERRORS, dropping oldest entries.
-     */
     private capErrors;
-    /**
-     * Kill a child process gracefully (SIGTERM, then SIGKILL after timeout).
-     *
-     * The promise resolves only when the process actually exits, not when
-     * SIGKILL is sent. Resolving on the SIGKILL timer was a race: callers
-     * (e.g. `runBuild`) would spawn a new build while the old Xcode process
-     * was still releasing DerivedData / build locks, causing cryptic
-     * SIGABRT or "file locked" errors on the new build.
-     *
-     * A hard upper-bound timer (2s after SIGKILL) guards against the
-     * pathological case where a process refuses to die at all, so callers
-     * never hang forever.
-     */
     private killProcess;
-    /**
-     * Run `npx expo prebuild --clean` synchronously (waits for exit).
-     */
     private runPrebuildClean;
-    /**
-     * Build and run the app on an iOS device or simulator.
-     * Auto-detects Expo vs bare React Native and uses the appropriate command:
-     *   - Expo: `npx expo run:ios`
-     *   - Bare RN: `npx react-native run-ios`
-     *
-     * Optionally runs `npx expo prebuild --clean` first (Expo only).
-     */
     runBuild(options?: RunBuildOptions): Promise<BuildResult>;
-    /**
-     * Start the Metro dev server.
-     * Auto-detects Expo vs bare React Native:
-     *   - Expo: `npx expo start --dev-client`
-     *   - Bare RN: `npx react-native start`
-     *
-     * Spawns Metro in the background and continuously captures output.
-     * Returns quickly once Metro shows signs of being ready (or after a timeout).
-     */
     startMetro(options?: StartMetroOptions): Promise<{
         success: boolean;
         message: string;
     }>;
-    /**
-     * Return all captured errors from both build and runtime contexts.
-     */
     getErrors(): AllErrors;
-    /**
-     * Return recent console output from Metro, optionally filtered by level.
-     */
     getConsole(options?: ConsoleOptions): string[];
-    /**
-     * Stop all managed Expo processes.
-     */
     stopAll(): Promise<string[]>;
-    /**
-     * Get the raw build output buffer (for diagnostics).
-     */
     getBuildOutput(): string[];
-    /**
-     * Get the raw metro output buffer (for diagnostics).
-     */
     getMetroOutput(): string[];
 }
 export {};