@ceraph/react-native-mcp 0.2.2 → 0.3.2

package/dist/shim/boot.d.ts

@@ -0,0 +1,41 @@
+interface LinkingLike {
+    addEventListener: (type: "url", handler: (event: {
+        url: string;
+    }) => void) => {
+        remove?: () => void;
+    } | undefined;
+}
+interface AppStateLike {
+    addEventListener: (type: "change", handler: (state: string) => void) => {
+        remove?: () => void;
+    } | undefined;
+}
+interface ApplyRegistryFn {
+    (): void;
+}
+interface KeepAwakeLike {
+    enable: () => {
+        applied: boolean;
+    };
+    disable: () => void;
+}
+interface InstallCeraphDeps {
+    linking?: LinkingLike;
+    appState?: AppStateLike | null;
+    keepAwake?: KeepAwakeLike | null;
+    applyCameraImageRegistry?: ApplyRegistryFn | null;
+}
+export interface InstallCeraphResult {
+    cameraRegistryApplied: boolean;
+    deepLinkListenerInstalled: boolean;
+    signalCapture: {
+        errorHandler: boolean;
+        fetchInterceptor: boolean;
+        reloadListener: boolean;
+    } | null;
+    keepAwakeActivated: boolean;
+    appStateListenerInstalled: boolean;
+}
+export declare function installCeraph(deps?: InstallCeraphDeps): InstallCeraphResult;
+export declare function _resetForTesting(): void;
+export {};

package/dist/shim/boot.js

@@ -0,0 +1,141 @@
+import { handleCeraphDeepLink } from "./deep-link.js";
+import { isDevRuntime } from "./dev-guard.js";
+import { disableKeepAwake, enableKeepAwake } from "./keep-awake.js";
+import { installSignalCapture } from "./signal-capture.js";
+let currentDeepLinkSub;
+let currentAppStateSub;
+export function installCeraph(deps = {}) {
+    if (!isDevRuntime()) {
+        return {
+            cameraRegistryApplied: false,
+            deepLinkListenerInstalled: false,
+            signalCapture: null,
+            keepAwakeActivated: false,
+            appStateListenerInstalled: false,
+        };
+    }
+    let cameraRegistryApplied = false;
+    const applyRegistry = deps.applyCameraImageRegistry === undefined
+        ? loadGeneratedRegistry()
+        : deps.applyCameraImageRegistry;
+    if (applyRegistry) {
+        try {
+            applyRegistry();
+            cameraRegistryApplied = true;
+        }
+        catch {
+        }
+    }
+    let deepLinkListenerInstalled = false;
+    currentDeepLinkSub?.remove?.();
+    currentDeepLinkSub = undefined;
+    let linking;
+    try {
+        linking = deps.linking ?? loadLinking();
+    }
+    catch {
+        linking = undefined;
+    }
+    if (linking && typeof linking.addEventListener === "function") {
+        const sub = linking.addEventListener("url", (event) => {
+            if (typeof event?.url === "string") {
+                handleCeraphDeepLink(event.url);
+            }
+        });
+        currentDeepLinkSub = sub;
+        deepLinkListenerInstalled = true;
+    }
+    const signalCapture = installSignalCapture();
+    let keepAwakeActivated = false;
+    const keepAwakeBinding = deps.keepAwake === undefined
+        ? {
+            enable: () => enableKeepAwake(),
+            disable: () => disableKeepAwake(),
+        }
+        : deps.keepAwake ?? { enable: () => ({ applied: false }), disable: () => undefined };
+    try {
+        const res = keepAwakeBinding.enable();
+        keepAwakeActivated = res.applied;
+    }
+    catch {
+        keepAwakeActivated = false;
+    }
+    let appStateListenerInstalled = false;
+    currentAppStateSub?.remove?.();
+    currentAppStateSub = undefined;
+    let appState;
+    try {
+        appState = deps.appState === undefined ? loadAppState() : deps.appState;
+    }
+    catch {
+        appState = null;
+    }
+    if (appState && typeof appState.addEventListener === "function") {
+        const sub = appState.addEventListener("change", (state) => {
+            if (state === "active") {
+                try {
+                    const res = keepAwakeBinding.enable();
+                    keepAwakeActivated = res.applied;
+                }
+                catch {
+                }
+            }
+            else {
+                try {
+                    keepAwakeBinding.disable();
+                }
+                catch {
+                }
+            }
+        });
+        currentAppStateSub = sub;
+        appStateListenerInstalled = true;
+    }
+    return {
+        cameraRegistryApplied,
+        deepLinkListenerInstalled,
+        signalCapture,
+        keepAwakeActivated,
+        appStateListenerInstalled,
+    };
+}
+function loadGeneratedRegistry() {
+    const req = globalThis.require;
+    if (typeof req !== "function")
+        return null;
+    const candidates = [
+        "../.ceraph/camera-images/_registry",
+        "./.ceraph/camera-images/_registry",
+    ];
+    for (const id of candidates) {
+        try {
+            const mod = req(id);
+            if (mod && typeof mod.applyCameraImageRegistry === "function") {
+                return mod.applyCameraImageRegistry;
+            }
+        }
+        catch {
+        }
+    }
+    return null;
+}
+function loadLinking() {
+    const req = globalThis.require;
+    if (typeof req !== "function")
+        return undefined;
+    const mod = req("react-native");
+    return mod?.Linking;
+}
+function loadAppState() {
+    const req = globalThis.require;
+    if (typeof req !== "function")
+        return undefined;
+    const mod = req("react-native");
+    return mod?.AppState;
+}
+export function _resetForTesting() {
+    currentDeepLinkSub?.remove?.();
+    currentDeepLinkSub = undefined;
+    currentAppStateSub?.remove?.();
+    currentAppStateSub = undefined;
+}

package/dist/shim/camera.d.ts

@@ -0,0 +1,22 @@
+import { type Ref, type ReactNode } from "react";
+export interface CeraphCameraProps {
+    facing?: "front" | "back";
+    flash?: "auto" | "on" | "off";
+    zoom?: number;
+    style?: unknown;
+    children?: ReactNode;
+    imageKey?: string;
+    [key: string]: unknown;
+}
+export interface CeraphCameraHandle {
+    takePictureAsync: (options?: Record<string, unknown>) => Promise<{
+        uri: string;
+        width: number;
+        height: number;
+        base64?: string;
+    }>;
+}
+export declare function buildTakePictureOverride(): CeraphCameraHandle["takePictureAsync"] | null;
+export declare const CeraphCamera: import("react").ForwardRefExoticComponent<CeraphCameraProps & {
+    ref?: Ref<CeraphCameraHandle> | undefined;
+}>;

package/dist/shim/camera.js

@@ -0,0 +1,62 @@
+import { createElement, forwardRef, useImperativeHandle, } from "react";
+import { View, Image } from "react-native";
+import { getCurrentTestImage, selectTestImageKey } from "./config.js";
+import { isDevRuntime } from "./dev-guard.js";
+function resolveTestImageUri(source) {
+    if (typeof source === "number") {
+        const resolved = Image.resolveAssetSource(source);
+        return resolved?.uri ?? "";
+    }
+    if (Array.isArray(source)) {
+        const first = source[0];
+        return first ? first.uri : "";
+    }
+    return source.uri;
+}
+export function buildTakePictureOverride() {
+    if (!isDevRuntime())
+        return null;
+    if (getCurrentTestImage() === null)
+        return null;
+    return async () => {
+        const live = getCurrentTestImage();
+        if (!live) {
+            return { uri: "", width: 0, height: 0, base64: undefined };
+        }
+        return {
+            uri: resolveTestImageUri(live),
+            width: 0,
+            height: 0,
+            base64: undefined,
+        };
+    };
+}
+export const CeraphCamera = forwardRef(function CeraphCamera(props, ref) {
+    if (isDevRuntime() &&
+        typeof props.imageKey === "string" &&
+        props.imageKey.length > 0 &&
+        !props.imageKey.startsWith("@")) {
+        selectTestImageKey(props.imageKey);
+    }
+    const override = buildTakePictureOverride();
+    useImperativeHandle(override !== null ? ref : null, () => ({ takePictureAsync: override }), [override]);
+    if (override !== null) {
+        const image = getCurrentTestImage();
+        const imageElement = image != null
+            ? createElement(Image, {
+                key: "ceraph-test-image",
+                source: image,
+                style: { width: "100%", height: "100%" },
+                resizeMode: "cover",
+            })
+            : null;
+        return createElement(View, {
+            style: props.style,
+            children: [imageElement, props.children],
+        });
+    }
+    const expoCamera = require("expo-camera");
+    const CameraView = expoCamera.CameraView;
+    return createElement(CameraView, { ...props, ref });
+});
+CeraphCamera.displayName = "CeraphCamera";

package/dist/shim/config.d.ts

@@ -0,0 +1,6 @@
+import type { ImageSourcePropType } from "react-native";
+export declare function configureTestImage(keyOrSource: string | ImageSourcePropType, source?: ImageSourcePropType): void;
+export declare function selectTestImageKey(key: string): void;
+export declare function getCurrentTestImage(): ImageSourcePropType | null;
+export declare function _resetForTesting(): void;
+export declare function _registerBundledDefaultForTesting(source: ImageSourcePropType): void;

package/dist/shim/config.js

@@ -0,0 +1,56 @@
+const registry = new Map();
+let currentKey = null;
+const DEFAULT_KEY = "default";
+let bundledDefaultRegistered = false;
+function ensureBundledDefault() {
+    if (bundledDefaultRegistered)
+        return;
+    bundledDefaultRegistered = true;
+    const req = globalThis.require;
+    if (typeof req !== "function")
+        return;
+    try {
+        const asset = req("../../assets/default.png");
+        if (asset != null && !registry.has(DEFAULT_KEY)) {
+            registry.set(DEFAULT_KEY, asset);
+        }
+    }
+    catch {
+    }
+}
+export function configureTestImage(keyOrSource, source) {
+    if (source === undefined) {
+        registry.set(DEFAULT_KEY, keyOrSource);
+        return;
+    }
+    if (typeof keyOrSource !== "string") {
+        throw new Error("configureTestImage: key must be a string when 2 args are passed");
+    }
+    registry.set(keyOrSource, source);
+}
+export function selectTestImageKey(key) {
+    currentKey = key;
+}
+export function getCurrentTestImage() {
+    if (currentKey && registry.has(currentKey)) {
+        return registry.get(currentKey) ?? null;
+    }
+    if (!registry.has(DEFAULT_KEY)) {
+        ensureBundledDefault();
+    }
+    if (registry.has(DEFAULT_KEY)) {
+        return registry.get(DEFAULT_KEY) ?? null;
+    }
+    return null;
+}
+export function _resetForTesting() {
+    registry.clear();
+    currentKey = null;
+    bundledDefaultRegistered = false;
+}
+export function _registerBundledDefaultForTesting(source) {
+    bundledDefaultRegistered = true;
+    if (!registry.has(DEFAULT_KEY)) {
+        registry.set(DEFAULT_KEY, source);
+    }
+}

package/dist/shim/deep-link.d.ts

@@ -0,0 +1 @@
+export declare function handleCeraphDeepLink(url: string): boolean;

package/dist/shim/deep-link.js

@@ -0,0 +1,25 @@
+import { selectTestImageKey } from "./config.js";
+const MAX_KEY_LEN = 255;
+export function handleCeraphDeepLink(url) {
+    if (!url)
+        return false;
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return false;
+    }
+    if (parsed.protocol !== "ceraph:")
+        return false;
+    const action = parsed.hostname;
+    if (action === "test-image") {
+        const key = parsed.searchParams.get("key");
+        if (key && key.length > 0 && key.length <= MAX_KEY_LEN) {
+            selectTestImageKey(key);
+            return true;
+        }
+        return false;
+    }
+    return false;
+}

package/dist/shim/dev-guard.d.ts

@@ -0,0 +1 @@
+export declare function isDevRuntime(): boolean;

package/dist/shim/dev-guard.js

@@ -0,0 +1,3 @@
+export function isDevRuntime() {
+    return typeof __DEV__ !== "undefined" && __DEV__ === true;
+}

package/dist/shim/error-handler.d.ts

@@ -0,0 +1,20 @@
+import { type TransportOptions } from "./signal-transport.js";
+interface ErrorUtilsLike {
+    getGlobalHandler?: () => ((error: Error, isFatal?: boolean) => void) | undefined;
+    setGlobalHandler: (handler: (error: Error, isFatal?: boolean) => void) => void;
+}
+interface HermesInternalLike {
+    enablePromiseRejectionTracker?: (opts: {
+        allRejections?: boolean;
+        onUnhandled?: (id: number, error: unknown) => void;
+        onHandled?: (id: number) => void;
+    }) => void;
+}
+export interface InstallErrorHandlerOptions {
+    transport?: TransportOptions;
+    errorUtils?: ErrorUtilsLike;
+    hermesInternal?: HermesInternalLike;
+}
+export declare function installErrorHandler(opts?: InstallErrorHandlerOptions): boolean;
+export declare function _resetForTesting(): void;
+export {};

package/dist/shim/error-handler.js

@@ -0,0 +1,66 @@
+import { isDevRuntime } from "./dev-guard.js";
+import { postSignal } from "./signal-transport.js";
+let installed = false;
+export function installErrorHandler(opts = {}) {
+    if (!isDevRuntime())
+        return false;
+    if (installed)
+        return false;
+    installed = true;
+    const utils = opts.errorUtils ??
+        globalThis.ErrorUtils;
+    if (utils && typeof utils.setGlobalHandler === "function") {
+        const previous = utils.getGlobalHandler?.();
+        utils.setGlobalHandler((error, isFatal) => {
+            void postSignal({
+                kind: "js-error",
+                message: error?.message ?? String(error),
+                stack: error?.stack,
+                timestampMs: Date.now(),
+            }, opts.transport);
+            try {
+                previous?.(error, isFatal);
+            }
+            catch {
+            }
+        });
+    }
+    const hermes = opts.hermesInternal ??
+        globalThis.HermesInternal;
+    if (hermes && typeof hermes.enablePromiseRejectionTracker === "function") {
+        hermes.enablePromiseRejectionTracker({
+            allRejections: true,
+            onUnhandled: (_id, error) => {
+                const message = extractMessage(error);
+                const stack = extractStack(error);
+                void postSignal({
+                    kind: "unhandled-rejection",
+                    message,
+                    stack,
+                    timestampMs: Date.now(),
+                }, opts.transport);
+            },
+        });
+    }
+    return true;
+}
+function extractMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === "string")
+        return error;
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return String(error);
+    }
+}
+function extractStack(error) {
+    if (error instanceof Error)
+        return error.stack;
+    return undefined;
+}
+export function _resetForTesting() {
+    installed = false;
+}

package/dist/shim/fetch-interceptor.d.ts

@@ -0,0 +1,13 @@
+import { type TransportOptions } from "./signal-transport.js";
+type FetchFn = (input: unknown, init?: unknown) => Promise<Response>;
+export interface InstallFetchInterceptorOptions {
+    transport?: TransportOptions;
+    globalRef?: {
+        fetch?: FetchFn;
+    };
+}
+export declare function installFetchInterceptor(opts?: InstallFetchInterceptorOptions): boolean;
+export declare function _uninstallForTesting(globalRef?: {
+    fetch?: FetchFn;
+}): void;
+export {};

package/dist/shim/fetch-interceptor.js

@@ -0,0 +1,93 @@
+import { isDevRuntime } from "./dev-guard.js";
+import { postSignal } from "./signal-transport.js";
+export function installFetchInterceptor(opts = {}) {
+    if (!isDevRuntime())
+        return false;
+    const target = opts.globalRef ?? globalThis;
+    const current = target.fetch;
+    if (typeof current !== "function")
+        return false;
+    const original = current.__ceraphOriginalFetch ?? current;
+    const wrapper = async (input, init) => {
+        const url = extractUrl(input);
+        const method = extractMethod(input, init);
+        const startedAt = Date.now();
+        try {
+            const response = await original(input, init);
+            const durationMs = Date.now() - startedAt;
+            const status = response.status;
+            if (status >= 500) {
+                void postSignal({
+                    kind: "network-error",
+                    message: `${method} ${url} → ${status}`,
+                    timestampMs: Date.now(),
+                    url,
+                    status,
+                    method,
+                    durationMs,
+                }, opts.transport);
+            }
+            else if (status >= 400) {
+                void postSignal({
+                    kind: "network-4xx",
+                    message: `${method} ${url} → ${status}`,
+                    timestampMs: Date.now(),
+                    url,
+                    status,
+                    method,
+                    durationMs,
+                }, opts.transport);
+            }
+            return response;
+        }
+        catch (err) {
+            const durationMs = Date.now() - startedAt;
+            void postSignal({
+                kind: "network-error",
+                message: `${method} ${url} failed: ${err?.message ?? String(err)}`,
+                stack: err?.stack,
+                timestampMs: Date.now(),
+                url,
+                method,
+                durationMs,
+            }, opts.transport);
+            throw err;
+        }
+    };
+    wrapper.__ceraphOriginalFetch = original;
+    target.fetch = wrapper;
+    return true;
+}
+function extractUrl(input) {
+    if (typeof input === "string")
+        return input;
+    if (input && typeof input === "object") {
+        const maybeUrl = input.url;
+        if (typeof maybeUrl === "string")
+            return maybeUrl;
+        if (typeof input.toString === "function") {
+            try {
+                return String(input);
+            }
+            catch {
+                return "<unknown-url>";
+            }
+        }
+    }
+    return "<unknown-url>";
+}
+function extractMethod(input, init) {
+    const fromInit = init?.method;
+    if (typeof fromInit === "string")
+        return fromInit.toUpperCase();
+    const fromRequest = input?.method;
+    if (typeof fromRequest === "string")
+        return fromRequest.toUpperCase();
+    return "GET";
+}
+export function _uninstallForTesting(globalRef = globalThis) {
+    const current = globalRef.fetch;
+    if (current?.__ceraphOriginalFetch) {
+        globalRef.fetch = current.__ceraphOriginalFetch;
+    }
+}

package/dist/shim/index.d.ts

@@ -0,0 +1,6 @@
+export { installCeraph, type InstallCeraphResult, } from "./boot.js";
+export { CeraphCamera, type CeraphCameraProps } from "./camera.js";
+export { configureTestImage, getCurrentTestImage, selectTestImageKey, } from "./config.js";
+export { handleCeraphDeepLink } from "./deep-link.js";
+export { installSignalCapture, type InstallSignalCaptureOptions, type InstallSignalCaptureResult, } from "./signal-capture.js";
+export { installReloadListener, triggerJsReload } from "./reload.js";

package/dist/shim/index.js

@@ -0,0 +1,6 @@
+export { installCeraph, } from "./boot.js";
+export { CeraphCamera } from "./camera.js";
+export { configureTestImage, getCurrentTestImage, selectTestImageKey, } from "./config.js";
+export { handleCeraphDeepLink } from "./deep-link.js";
+export { installSignalCapture, } from "./signal-capture.js";
+export { installReloadListener, triggerJsReload } from "./reload.js";

package/dist/shim/keep-awake.d.ts

@@ -0,0 +1,13 @@
+interface KeepAwakeModuleLike {
+    activate?: () => void;
+    deactivate?: () => void;
+}
+export declare function _resetForTesting(): void;
+export declare function _setProviderForTesting(provider: KeepAwakeModuleLike | null): void;
+export interface KeepAwakeResult {
+    applied: boolean;
+    provider: "expo-keep-awake" | "react-native-keep-awake" | "RNCKeepAwake" | null;
+}
+export declare function enableKeepAwake(): KeepAwakeResult;
+export declare function disableKeepAwake(): void;
+export {};