@ceraph/react-native-mcp 0.2.2 → 0.3.2

package/dist/shim/keep-awake.js

@@ -0,0 +1,118 @@
+import { isDevRuntime } from "./dev-guard.js";
+let resolvedProvider;
+let resolvedProviderId;
+let active = false;
+export function _resetForTesting() {
+    resolvedProvider = undefined;
+    resolvedProviderId = undefined;
+    active = false;
+}
+export function _setProviderForTesting(provider) {
+    resolvedProvider = provider;
+    resolvedProviderId = provider ? "test-injected" : null;
+    active = false;
+}
+function resolveProvider() {
+    const req = globalThis.require;
+    if (typeof req === "function") {
+        try {
+            const mod = req("expo-keep-awake");
+            if (mod) {
+                const activate = typeof mod.activateKeepAwakeAsync === "function"
+                    ? () => {
+                        void mod.activateKeepAwakeAsync?.();
+                    }
+                    : typeof mod.activateKeepAwake === "function"
+                        ? () => mod.activateKeepAwake()
+                        : undefined;
+                const deactivate = typeof mod.deactivateKeepAwake === "function"
+                    ? () => mod.deactivateKeepAwake()
+                    : undefined;
+                if (activate) {
+                    return {
+                        provider: { activate, deactivate },
+                        id: "expo-keep-awake",
+                    };
+                }
+            }
+        }
+        catch {
+        }
+        try {
+            const mod = req("react-native-keep-awake");
+            const candidate = (mod && mod.default) ??
+                mod;
+            if (candidate && typeof candidate.activate === "function") {
+                return { provider: candidate, id: "react-native-keep-awake" };
+            }
+        }
+        catch {
+        }
+        try {
+            const rn = req("react-native");
+            const nm = rn?.NativeModules?.RNCKeepAwake;
+            if (nm && typeof nm.activate === "function") {
+                return { provider: nm, id: "RNCKeepAwake" };
+            }
+        }
+        catch {
+        }
+    }
+    return null;
+}
+export function enableKeepAwake() {
+    if (!isDevRuntime())
+        return { applied: false, provider: null };
+    if (active) {
+        return { applied: true, provider: providerIdForResult() };
+    }
+    if (resolvedProvider === undefined) {
+        const resolution = resolveProvider();
+        if (resolution) {
+            resolvedProvider = resolution.provider;
+            resolvedProviderId = resolution.id;
+        }
+        else {
+            resolvedProvider = null;
+            resolvedProviderId = null;
+        }
+    }
+    if (!resolvedProvider || typeof resolvedProvider.activate !== "function") {
+        return { applied: false, provider: null };
+    }
+    try {
+        resolvedProvider.activate();
+        active = true;
+        return { applied: true, provider: providerIdForResult() };
+    }
+    catch (err) {
+        const consoleObj = globalThis.console;
+        consoleObj?.warn?.(`[ceraph] keep-awake: provider activate() threw — ${err.message ?? "unknown"}`);
+        return { applied: false, provider: null };
+    }
+}
+export function disableKeepAwake() {
+    if (!active)
+        return;
+    active = false;
+    const provider = resolvedProvider;
+    if (!provider || typeof provider.deactivate !== "function")
+        return;
+    try {
+        provider.deactivate();
+    }
+    catch {
+    }
+}
+function providerIdForResult() {
+    if (!resolvedProvider)
+        return null;
+    switch (resolvedProviderId) {
+        case "expo-keep-awake":
+        case "react-native-keep-awake":
+        case "RNCKeepAwake":
+            return resolvedProviderId;
+        default:
+            return null;
+    }
+}

package/dist/shim/reload.d.ts

@@ -0,0 +1,23 @@
+interface DevSettingsLike {
+    reload?: () => void;
+}
+interface LinkingLike {
+    addEventListener: (type: "url", handler: (event: {
+        url: string;
+    }) => void) => {
+        remove?: () => void;
+    } | undefined;
+}
+interface ReloadDeps {
+    devSettings?: DevSettingsLike;
+    linking?: LinkingLike;
+}
+export declare function triggerJsReload(deps?: ReloadDeps): boolean;
+export interface InstallReloadListenerResult {
+    installed: boolean;
+    remove: () => void;
+}
+export declare function installReloadListener(deps?: ReloadDeps): InstallReloadListenerResult;
+export declare function _resetForTesting(): void;
+export declare function _isInstalledForTesting(): boolean;
+export {};

package/dist/shim/reload.js

@@ -0,0 +1,76 @@
+import { isDevRuntime } from "./dev-guard.js";
+let installed = false;
+let currentSubscription;
+export function triggerJsReload(deps = {}) {
+    if (!isDevRuntime())
+        return false;
+    try {
+        const devSettings = deps.devSettings ?? loadDevSettings();
+        if (devSettings && typeof devSettings.reload === "function") {
+            devSettings.reload();
+            return true;
+        }
+    }
+    catch {
+    }
+    return false;
+}
+export function installReloadListener(deps = {}) {
+    const noop = {
+        installed: false,
+        remove: () => undefined,
+    };
+    if (!isDevRuntime())
+        return noop;
+    currentSubscription?.remove?.();
+    currentSubscription = undefined;
+    let linking;
+    try {
+        linking = deps.linking ?? loadLinking();
+    }
+    catch {
+        return noop;
+    }
+    if (!linking || typeof linking.addEventListener !== "function") {
+        return noop;
+    }
+    const sub = linking.addEventListener("url", (event) => {
+        if (typeof event?.url !== "string")
+            return;
+        if (event.url === "ceraph://reload" || event.url.startsWith("ceraph://reload?")) {
+            triggerJsReload(deps);
+        }
+    });
+    currentSubscription = sub;
+    installed = true;
+    return {
+        installed: true,
+        remove: () => {
+            sub?.remove?.();
+            if (currentSubscription === sub)
+                currentSubscription = undefined;
+        },
+    };
+}
+function loadDevSettings() {
+    const req = globalThis.require;
+    if (typeof req !== "function")
+        return undefined;
+    const mod = req("react-native");
+    return mod?.DevSettings;
+}
+function loadLinking() {
+    const req = globalThis.require;
+    if (typeof req !== "function")
+        return undefined;
+    const mod = req("react-native");
+    return mod?.Linking;
+}
+export function _resetForTesting() {
+    currentSubscription?.remove?.();
+    currentSubscription = undefined;
+    installed = false;
+}
+export function _isInstalledForTesting() {
+    return installed;
+}

package/dist/shim/signal-capture.d.ts

@@ -0,0 +1,11 @@
+import type { TransportOptions } from "./signal-transport.js";
+export interface InstallSignalCaptureOptions {
+    transport?: TransportOptions;
+    installReloadListener?: boolean;
+}
+export interface InstallSignalCaptureResult {
+    errorHandler: boolean;
+    fetchInterceptor: boolean;
+    reloadListener: boolean;
+}
+export declare function installSignalCapture(opts?: InstallSignalCaptureOptions): InstallSignalCaptureResult;

package/dist/shim/signal-capture.js

@@ -0,0 +1,15 @@
+import { installErrorHandler } from "./error-handler.js";
+import { installFetchInterceptor } from "./fetch-interceptor.js";
+import { installReloadListener } from "./reload.js";
+export function installSignalCapture(opts = {}) {
+    const wantReload = opts.installReloadListener !== false;
+    let reloadListener = false;
+    if (wantReload) {
+        reloadListener = installReloadListener().installed;
+    }
+    return {
+        errorHandler: installErrorHandler({ transport: opts.transport }),
+        fetchInterceptor: installFetchInterceptor({ transport: opts.transport }),
+        reloadListener,
+    };
+}

package/dist/shim/signal-transport.d.ts

@@ -0,0 +1,17 @@
+export type SignalKind = "js-error" | "unhandled-rejection" | "network-error" | "network-4xx";
+export interface SignalPayload {
+    kind: SignalKind;
+    message: string;
+    stack?: string;
+    timestampMs: number;
+    url?: string;
+    status?: number;
+    method?: string;
+    durationMs?: number;
+}
+export interface TransportOptions {
+    host?: string;
+    port?: number;
+    rethrowOnFailure?: boolean;
+}
+export declare function postSignal(payload: SignalPayload, opts?: TransportOptions): Promise<void>;

package/dist/shim/signal-transport.js

@@ -0,0 +1,43 @@
+import { isDevRuntime } from "./dev-guard.js";
+const DEFAULT_HOST = "localhost";
+const DEFAULT_PORT = 8101;
+const POST_TIMEOUT_MS = 1500;
+function resolveEndpoint(opts = {}) {
+    let envHost;
+    let envPort;
+    if (typeof globalThis !== "undefined") {
+        const proc = globalThis.process;
+        envHost = proc?.env?.CERAPH_SIGNAL_HOST;
+        envPort = proc?.env?.CERAPH_SIGNAL_PORT;
+    }
+    const host = opts.host ?? envHost ?? DEFAULT_HOST;
+    const port = opts.port ?? (envPort ? Number.parseInt(envPort, 10) : DEFAULT_PORT);
+    return { host, port: Number.isFinite(port) ? port : DEFAULT_PORT };
+}
+export async function postSignal(payload, opts = {}) {
+    if (!isDevRuntime())
+        return;
+    const { host, port } = resolveEndpoint(opts);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), POST_TIMEOUT_MS);
+    try {
+        const fetchFn = globalThis.fetch;
+        if (typeof fetchFn !== "function")
+            return;
+        await fetchFn(`http://${host}:${port}/signal`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(payload),
+            signal: controller.signal,
+        });
+    }
+    catch (err) {
+        if (opts.rethrowOnFailure)
+            throw err;
+        const consoleObj = globalThis.console;
+        consoleObj?.warn?.(`[ceraph] signal transport: failed to post ${payload.kind} (${err.message ?? "unknown"})`);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/dist/signal-listener.d.ts

@@ -0,0 +1,27 @@
+import type { RNManager } from "./expo-manager.js";
+export interface SignalListenerOptions {
+    port?: number;
+    host?: string;
+}
+export interface SignalListenerStartResult {
+    ok: boolean;
+    port: number;
+    error?: string;
+    errorCode?: string;
+}
+export declare class SignalListener {
+    private rnManager;
+    private server;
+    private port;
+    private hostOverride;
+    constructor(rnManager: Pick<RNManager, "appendShimSignal">, opts?: SignalListenerOptions);
+    start(): Promise<SignalListenerStartResult>;
+    stop(): Promise<void>;
+    handleForTesting(payload: unknown): Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+    private handle;
+    private appendIfValid;
+    private readBody;
+}

package/dist/signal-listener.js

@@ -0,0 +1,135 @@
+import { createServer } from "node:http";
+const DEFAULT_PORT = 8101;
+const MAX_BODY_BYTES = 64 * 1024;
+const KNOWN_KINDS = new Set([
+    "metro-error",
+    "js-error",
+    "unhandled-rejection",
+    "network-error",
+    "network-4xx",
+]);
+const DEFAULT_HOST = "127.0.0.1";
+export class SignalListener {
+    rnManager;
+    server = null;
+    port;
+    hostOverride;
+    constructor(rnManager, opts = {}) {
+        this.rnManager = rnManager;
+        this.port = opts.port ?? DEFAULT_PORT;
+        this.hostOverride = opts.host ?? null;
+    }
+    async start() {
+        const host = this.hostOverride ?? process.env.CERAPH_SIGNAL_HOST ?? DEFAULT_HOST;
+        return new Promise((resolve) => {
+            const server = createServer((req, res) => this.handle(req, res));
+            server.once("error", (err) => {
+                resolve({
+                    ok: false,
+                    port: this.port,
+                    error: err.message ?? err.code ?? "listen failed",
+                    errorCode: err.code,
+                });
+            });
+            server.listen(this.port, host, () => {
+                this.server = server;
+                resolve({ ok: true, port: this.port });
+            });
+        });
+    }
+    async stop() {
+        const server = this.server;
+        if (!server)
+            return;
+        this.server = null;
+        await new Promise((resolve) => server.close(() => resolve()));
+    }
+    async handleForTesting(payload) {
+        return this.appendIfValid(payload);
+    }
+    async handle(req, res) {
+        if (req.method !== "POST" || req.url !== "/signal") {
+            res.statusCode = 404;
+            res.end();
+            return;
+        }
+        const body = await this.readBody(req).catch((err) => ({
+            tooLarge: false,
+            err: err,
+        }));
+        if ("err" in body) {
+            res.statusCode = 400;
+            res.end(JSON.stringify({ ok: false, error: body.err.message }));
+            return;
+        }
+        if (body.tooLarge) {
+            res.statusCode = 413;
+            res.end(JSON.stringify({ ok: false, error: "payload too large" }));
+            return;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(body.text);
+        }
+        catch (err) {
+            res.statusCode = 400;
+            res.end(JSON.stringify({ ok: false, error: err.message }));
+            return;
+        }
+        const outcome = await this.appendIfValid(parsed);
+        if (!outcome.ok) {
+            res.statusCode = 400;
+            res.end(JSON.stringify(outcome));
+            return;
+        }
+        res.statusCode = 204;
+        res.end();
+    }
+    async appendIfValid(payload) {
+        if (!payload || typeof payload !== "object") {
+            return { ok: false, error: "payload must be an object" };
+        }
+        const p = payload;
+        if (typeof p.message !== "string" || p.message.length === 0) {
+            return { ok: false, error: "message is required" };
+        }
+        if (typeof p.kind !== "string" || !KNOWN_KINDS.has(p.kind)) {
+            return { ok: false, error: `unknown kind: ${String(p.kind)}` };
+        }
+        const timestamp = typeof p.timestampMs === "number" && Number.isFinite(p.timestampMs)
+            ? new Date(p.timestampMs).toISOString()
+            : new Date().toISOString();
+        await this.rnManager.appendShimSignal({
+            message: p.message,
+            stack: typeof p.stack === "string" ? p.stack : "",
+            timestamp,
+            kind: p.kind,
+            url: typeof p.url === "string" ? p.url : undefined,
+            status: typeof p.status === "number" ? p.status : undefined,
+            method: typeof p.method === "string" ? p.method : undefined,
+            durationMs: typeof p.durationMs === "number" ? p.durationMs : undefined,
+        });
+        return { ok: true };
+    }
+    readBody(req) {
+        return new Promise((resolve, reject) => {
+            let received = 0;
+            const chunks = [];
+            req.on("data", (chunk) => {
+                received += chunk.length;
+                if (received > MAX_BODY_BYTES) {
+                    chunks.length = 0;
+                    resolve({ text: "", tooLarge: true });
+                    req.removeAllListeners("data");
+                    req.removeAllListeners("end");
+                    req.on("data", () => undefined);
+                    req.on("end", () => undefined);
+                    return;
+                }
+                chunks.push(chunk);
+            });
+            req.on("end", () => resolve({ text: Buffer.concat(chunks).toString("utf-8"), tooLarge: false }));
+            req.on("error", reject);
+        });
+    }
+}

package/dist/simulator-boot.d.ts

@@ -0,0 +1,52 @@
+export interface BootSimulatorOpts {
+    udid?: string;
+    deviceType?: string;
+    bootTimeoutMs?: number;
+}
+export type BootSimulatorResult = {
+    udid: string;
+    deviceType: string;
+    alreadyBooted: boolean;
+    booted: true;
+    runtime: string;
+    durationMs: number;
+};
+export interface SimctlDeviceEntry {
+    udid: string;
+    name: string;
+    state: string;
+    runtime?: string;
+    isAvailable?: boolean;
+}
+export interface SimctlListResult {
+    devices: Record<string, SimctlDeviceEntry[]>;
+}
+export interface CommandResult {
+    code: number;
+    stdout: string;
+    stderr: string;
+}
+export interface BootSimulatorDeps {
+    runner: (cmd: string, args: string[], timeoutMs?: number) => Promise<CommandResult>;
+}
+export declare function runXcrun(cmd: string, args: string[], timeoutMs?: number): Promise<CommandResult>;
+export declare const defaultBootSimulatorDeps: BootSimulatorDeps;
+export declare function parseIosRuntimeVersion(runtimeKey: string): {
+    major: number;
+    minor: number;
+    label: string;
+} | null;
+export declare function pickBestSimulator(list: SimctlListResult, deviceType?: string): {
+    udid: string;
+    name: string;
+    runtimeLabel: string;
+    state: string;
+} | null;
+export declare function findSimulatorByUdid(list: SimctlListResult, udid: string): {
+    udid: string;
+    name: string;
+    runtimeLabel: string;
+    state: string;
+} | null;
+export declare function isAlreadyBootedError(stderr: string): boolean;
+export declare function bootSimulator(opts?: BootSimulatorOpts, deps?: BootSimulatorDeps): Promise<BootSimulatorResult>;