@ceraph/react-native-mcp 0.2.1 → 0.3.1

package/dist/init/shell-profile.js

@@ -0,0 +1,85 @@
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, dirname } from "node:path";
+const SENTINEL_HEAD = "# Ceraph signal host — auto-set by @ceraph/react-native-mcp init";
+const SENTINEL_TAIL = "# End Ceraph signal host";
+function isValidIpv4(input) {
+    if (typeof input !== "string")
+        return false;
+    const parts = input.split(".");
+    if (parts.length !== 4)
+        return false;
+    for (const part of parts) {
+        if (!/^[0-9]+$/.test(part))
+            return false;
+        if (part.length > 1 && part.startsWith("0"))
+            return false;
+        const n = Number(part);
+        if (!Number.isInteger(n))
+            return false;
+        if (n < 0 || n > 255)
+            return false;
+    }
+    return true;
+}
+export function pickShellProfile(deps = {}) {
+    const env = deps.env ?? process.env;
+    const home = deps.home ?? homedir();
+    const shellPath = env.SHELL ?? "";
+    if (shellPath.endsWith("/bash")) {
+        return { path: join(home, ".bashrc"), shell: "bash" };
+    }
+    return { path: join(home, ".zshrc"), shell: "zsh" };
+}
+export async function writeSignalHostEnv(ip, deps = {}) {
+    if (!isValidIpv4(ip)) {
+        throw new Error(`writeSignalHostEnv: refusing non-IPv4 input ${JSON.stringify(ip)} — ` +
+            `expected a dotted-quad like 192.168.1.42 with each octet 0-255`);
+    }
+    const target = deps.target ?? pickShellProfile();
+    const read = deps.readFile ?? ((p) => readFile(p, "utf-8"));
+    const write = deps.writeFile ?? ((p, c) => writeFile(p, c, "utf-8"));
+    const ensureDir = deps.mkdir ?? ((p, o) => mkdir(p, o));
+    let body = "";
+    try {
+        body = await read(target.path);
+    }
+    catch {
+        body = "";
+    }
+    const block = `${SENTINEL_HEAD}\n` +
+        `export CERAPH_SIGNAL_HOST=${ip}\n` +
+        `${SENTINEL_TAIL}\n`;
+    const existingBlock = extractSentinelBlock(body);
+    if (existingBlock) {
+        if (existingBlock.value === ip) {
+            return { path: target.path, shell: target.shell, state: "unchanged" };
+        }
+        const next = body.slice(0, existingBlock.start) +
+            block +
+            body.slice(existingBlock.end);
+        await ensureDir(dirname(target.path), { recursive: true });
+        await write(target.path, next);
+        return { path: target.path, shell: target.shell, state: "updated" };
+    }
+    const prefix = body === "" || body.endsWith("\n") ? "" : "\n";
+    const separator = body === "" ? "" : "\n";
+    const next = body + prefix + separator + block;
+    await ensureDir(dirname(target.path), { recursive: true });
+    await write(target.path, next);
+    return { path: target.path, shell: target.shell, state: "added" };
+}
+function extractSentinelBlock(body) {
+    const headIdx = body.indexOf(SENTINEL_HEAD);
+    if (headIdx === -1)
+        return null;
+    const tailIdx = body.indexOf(SENTINEL_TAIL, headIdx);
+    if (tailIdx === -1)
+        return null;
+    const afterTail = tailIdx + SENTINEL_TAIL.length;
+    const end = body[afterTail] === "\n" ? afterTail + 1 : afterTail;
+    const between = body.slice(headIdx, end);
+    const exportMatch = between.match(/export\s+CERAPH_SIGNAL_HOST=(\S+)/);
+    const value = exportMatch ? exportMatch[1] : "";
+    return { start: headIdx, end, value };
+}

package/dist/init/steps.d.ts

@@ -0,0 +1,135 @@
+import { type PackageManager } from "./package-manager.js";
+import { type RootComponentTarget } from "./ast-layout.js";
+import { type SchemeAction } from "./url-scheme.js";
+import { type MonorepoCandidate } from "./monorepo.js";
+import { syncCameraRegistry, relativeRegistryPath } from "../camera-registry-sync.js";
+import { type PreflightCheck } from "../preflight.js";
+import { ScreenManager } from "../screen.js";
+import { AppLifecycle } from "../app-lifecycle.js";
+import { DeviceAutonomy } from "../device-autonomy.js";
+import type { TargetResolver } from "../target.js";
+export interface InitStatus {
+    workingDir: string;
+    packageInstalled: boolean;
+    authenticated: boolean;
+    authLogin?: string;
+    schemeRegistered: boolean | null;
+    projectKind: "expo-json" | "expo-config" | "bare-rn" | "none";
+    cameraScanResults: Array<{
+        relPath: string;
+        line: number;
+        alreadyHasImageKey: boolean;
+        suggestedKey: string;
+    }>;
+    bootInjected: boolean | null;
+    bootTarget: RootComponentTarget | null;
+    mcpClientsPresent: {
+        claudeCode: boolean;
+        cursor: boolean;
+        codex: boolean;
+        vscode: boolean;
+    };
+}
+export declare function getInitStatus(projectDir: string): Promise<InitStatus>;
+export interface InstallPackageResult {
+    already: boolean;
+    packageManager: PackageManager;
+    exitCode?: number;
+}
+export declare function installCeraphPackage(projectDir: string, deps?: {
+    spawnInstall?: (input: {
+        bin: string;
+        args: string[];
+        cwd: string;
+    }) => Promise<{
+        exitCode: number;
+    }>;
+}): Promise<InstallPackageResult>;
+export interface AuthStartResult {
+    verificationUri: string;
+    userCode: string;
+    pollUrl: string;
+    expiresIn: number;
+    intervalSeconds: number;
+}
+export declare function startAuthFlow(): Promise<AuthStartResult>;
+export type AuthPollResult = {
+    status: "pending";
+} | {
+    status: "slow_down";
+    intervalSeconds: number;
+} | {
+    status: "complete";
+    login: string;
+} | {
+    status: "failed";
+    reason: "expired" | "denied" | "unknown-poll-url";
+};
+export declare function pollAuthFlow(pollUrl: string): Promise<AuthPollResult>;
+export interface ScanCameraUsage {
+    filePath: string;
+    relPath: string;
+    line: number;
+    suggestedKey: string;
+    alreadyHasImageKey: boolean;
+    surroundingCode: string;
+}
+export declare function scanCameraUsages(projectDir: string): Promise<{
+    usages: ScanCameraUsage[];
+    filesScanned: number;
+}>;
+export interface ReplaceCameraInput {
+    filePath: string;
+    line: number;
+    imageKey: string;
+}
+export interface ReplaceCameraResult {
+    success: boolean;
+    already?: boolean;
+    newContent?: string;
+    reason?: string;
+}
+export declare function replaceCameraView(projectDir: string, input: ReplaceCameraInput): Promise<ReplaceCameraResult>;
+export interface InjectBootResult {
+    applied: boolean;
+    filePath?: string;
+    already?: boolean;
+    reason?: string;
+}
+export declare function injectBoot(projectDir: string): Promise<InjectBootResult>;
+export interface RegisterSchemeResult {
+    action: SchemeAction;
+    instructions?: string;
+}
+export declare function registerScheme(projectDir: string): Promise<RegisterSchemeResult>;
+export interface SetupImagesDirResult {
+    dirPath: string;
+    readmeWritten: boolean;
+    gitignoreUpdated: boolean;
+}
+export declare function setupImagesDir(projectDir: string): Promise<SetupImagesDirResult>;
+export interface SetupMcpClientsResult {
+    written: string[];
+    skipped: string[];
+}
+export declare function setupMcpClients(projectDir: string): Promise<SetupMcpClientsResult>;
+export interface PreflightToolResult {
+    ok: boolean;
+    passedCount: number;
+    totalCount: number;
+    checks: PreflightCheck[];
+}
+export declare function preflightForMcp(projectDir: string, deps?: {
+    screen?: ScreenManager;
+    apps?: AppLifecycle;
+    autonomy?: DeviceAutonomy;
+    target?: TargetResolver;
+    iproxyManager?: import("../iproxy-manager.js").IproxyManager | null;
+}): Promise<PreflightToolResult>;
+export interface MonorepoStatusResult {
+    isMonorepo: boolean;
+    rootIsRnApp: boolean;
+    matches: MonorepoCandidate[];
+}
+export declare function detectMonorepoStatus(projectDir: string): Promise<MonorepoStatusResult>;
+export { syncCameraRegistry, relativeRegistryPath };

package/dist/init/steps.js

@@ -0,0 +1,399 @@
+import { randomBytes } from "node:crypto";
+import { spawn } from "node:child_process";
+import { mkdir, readFile, writeFile, access } from "node:fs/promises";
+import { join } from "node:path";
+import { detectPackageManager, installArgv, isPackageInstalled, } from "./package-manager.js";
+import { finalizeAndPersist, pollDeviceFlow, readExistingAuth, startDeviceFlow, } from "./oauth.js";
+import { applyCameraEdits, scanCameraViews, setImageKeyOnExistingTag, } from "./ast-camera.js";
+import { detectRootComponent, injectInstallCeraph, } from "./ast-layout.js";
+import { ensureCeraphUrlScheme, bareRnInstructions, expoDynamicConfigInstructions, } from "./url-scheme.js";
+import { detectMonorepoSubpackages, } from "./monorepo.js";
+import { syncCameraRegistry, relativeRegistryPath, } from "../camera-registry-sync.js";
+import { runPreflight } from "../preflight.js";
+import { ScreenManager } from "../screen.js";
+import { AppLifecycle } from "../app-lifecycle.js";
+import { DeviceAutonomy } from "../device-autonomy.js";
+export async function getInitStatus(projectDir) {
+    const [pkgInstalled, auth, scheme, scan, bootTarget] = await Promise.all([
+        isPackageInstalled(projectDir),
+        readExistingAuth(),
+        ensureCeraphUrlSchemeReadOnly(projectDir),
+        scanCameraViews(projectDir),
+        detectRootComponent(projectDir),
+    ]);
+    const bootInjected = bootTarget
+        ? (await readFile(bootTarget.filePath, "utf-8")).includes("installCeraph(")
+        : null;
+    const schemeRegistered = scheme.kind === "expo-json-already-registered"
+        ? true
+        : scheme.kind === "expo-json-added"
+            ?
+                false
+            : null;
+    const projectKind = scheme.kind === "expo-json-added" ||
+        scheme.kind === "expo-json-already-registered"
+        ? "expo-json"
+        : scheme.kind === "expo-config-needs-manual"
+            ? "expo-config"
+            : scheme.kind === "bare-rn-needs-manual"
+                ? "bare-rn"
+                : "none";
+    return {
+        workingDir: projectDir,
+        packageInstalled: pkgInstalled,
+        authenticated: auth != null,
+        authLogin: auth?.githubUser.login,
+        schemeRegistered,
+        projectKind,
+        cameraScanResults: scan.edits.map((e) => ({
+            relPath: e.relPath,
+            line: e.line,
+            alreadyHasImageKey: e.alreadyHasImageKey,
+            suggestedKey: e.suggestedKey,
+        })),
+        bootInjected,
+        bootTarget,
+        mcpClientsPresent: {
+            claudeCode: await fileExists(join(projectDir, ".mcp.json")),
+            cursor: await fileExists(join(projectDir, ".cursor", "mcp.json")),
+            codex: await fileExists(join(projectDir, ".codex", "config.toml")),
+            vscode: await fileExists(join(projectDir, ".vscode", "mcp.json")),
+        },
+    };
+}
+async function ensureCeraphUrlSchemeReadOnly(projectDir) {
+    return ensureCeraphUrlScheme(projectDir, {
+        writeFile: async () => undefined,
+    });
+}
+export async function installCeraphPackage(projectDir, deps = {}) {
+    const pm = await detectPackageManager(projectDir);
+    if (await isPackageInstalled(projectDir)) {
+        return { already: true, packageManager: pm };
+    }
+    const argv = installArgv(pm);
+    const installer = deps.spawnInstall ?? defaultSpawnInstall;
+    const res = await installer({ bin: argv.bin, args: argv.args, cwd: projectDir });
+    return { already: false, packageManager: pm, exitCode: res.exitCode };
+}
+function defaultSpawnInstall(input) {
+    return new Promise((resolve) => {
+        const child = spawn(input.bin, input.args, {
+            cwd: input.cwd,
+            stdio: "inherit",
+        });
+        child.on("error", () => resolve({ exitCode: 127 }));
+        child.on("exit", (code) => resolve({ exitCode: code ?? 1 }));
+    });
+}
+const deviceFlows = new Map();
+export async function startAuthFlow() {
+    const now = Date.now();
+    for (const [key, entry] of deviceFlows) {
+        if (now - entry.createdAt > 15 * 60_000)
+            deviceFlows.delete(key);
+    }
+    const start = await startDeviceFlow();
+    const pollUrl = randomBytes(16).toString("hex");
+    deviceFlows.set(pollUrl, {
+        start,
+        deviceCode: start.deviceCode,
+        createdAt: Date.now(),
+    });
+    return {
+        verificationUri: start.verificationUri,
+        userCode: start.userCode,
+        pollUrl,
+        expiresIn: start.expiresIn,
+        intervalSeconds: start.intervalSeconds,
+    };
+}
+export async function pollAuthFlow(pollUrl) {
+    const entry = deviceFlows.get(pollUrl);
+    if (!entry)
+        return { status: "failed", reason: "unknown-poll-url" };
+    const result = await pollDeviceFlow(entry.deviceCode);
+    if (result.kind === "pending")
+        return { status: "pending" };
+    if (result.kind === "slow_down")
+        return { status: "slow_down", intervalSeconds: result.intervalSeconds };
+    if (result.kind === "expired") {
+        deviceFlows.delete(pollUrl);
+        return { status: "failed", reason: "expired" };
+    }
+    if (result.kind === "denied") {
+        deviceFlows.delete(pollUrl);
+        return { status: "failed", reason: "denied" };
+    }
+    const stored = await finalizeAndPersist(result.accessToken);
+    deviceFlows.delete(pollUrl);
+    return { status: "complete", login: stored.githubUser.login };
+}
+export async function scanCameraUsages(projectDir) {
+    const scan = await scanCameraViews(projectDir);
+    const usages = [];
+    const cache = new Map();
+    for (const edit of scan.edits) {
+        let body = cache.get(edit.filePath);
+        if (body === undefined) {
+            body = await readFile(edit.filePath, "utf-8").catch(() => "");
+            cache.set(edit.filePath, body);
+        }
+        usages.push({
+            filePath: edit.filePath,
+            relPath: edit.relPath,
+            line: edit.line,
+            suggestedKey: edit.suggestedKey,
+            alreadyHasImageKey: edit.alreadyHasImageKey,
+            surroundingCode: extractWindow(body, edit.line, 15),
+        });
+    }
+    return { usages, filesScanned: scan.filesScanned };
+}
+function extractWindow(body, centerLine, half) {
+    const lines = body.split(/\r?\n/);
+    const start = Math.max(0, centerLine - 1 - half);
+    const end = Math.min(lines.length, centerLine - 1 + half + 1);
+    return lines.slice(start, end).join("\n");
+}
+export async function replaceCameraView(projectDir, input) {
+    const scan = await scanCameraViews(projectDir);
+    const match = scan.edits.find((e) => e.filePath === input.filePath && e.line === input.line);
+    if (!match) {
+        const body = await readFile(input.filePath, "utf-8").catch(() => null);
+        if (body == null) {
+            return {
+                success: false,
+                reason: `File not found: ${input.filePath}`,
+            };
+        }
+        if (body.includes("CeraphCamera")) {
+            const res = await setImageKeyOnExistingTag(input.filePath, input.line, input.imageKey);
+            if (res.applied) {
+                const newContent = await readFile(input.filePath, "utf-8");
+                return { success: true, newContent };
+            }
+            if (res.reason === "imageKey unchanged") {
+                return { success: true, already: true, newContent: body };
+            }
+            return {
+                success: false,
+                reason: res.reason ?? `No <CeraphCamera> at ${input.filePath}:${input.line}`,
+            };
+        }
+        return {
+            success: false,
+            reason: `No <CameraView> at ${input.filePath}:${input.line}`,
+        };
+    }
+    const edit = {
+        filePath: match.filePath,
+        relPath: match.relPath,
+        line: match.line,
+        suggestedKey: input.imageKey,
+        alreadyHasImageKey: match.alreadyHasImageKey,
+    };
+    await applyCameraEdits(projectDir, [edit]);
+    const newContent = await readFile(input.filePath, "utf-8");
+    return { success: true, newContent };
+}
+export async function injectBoot(projectDir) {
+    const target = await detectRootComponent(projectDir);
+    if (!target) {
+        return {
+            applied: false,
+            reason: "Could not find app/_layout.tsx or App.tsx — add `useEffect(() => { installCeraph(); }, [])` manually.",
+        };
+    }
+    const body = await readFile(target.filePath, "utf-8").catch(() => "");
+    const alreadyCalled = body.includes("installCeraph(");
+    const result = await injectInstallCeraph(target);
+    return {
+        applied: result.applied,
+        filePath: target.filePath,
+        already: alreadyCalled,
+        reason: result.reason,
+    };
+}
+export async function registerScheme(projectDir) {
+    const action = await ensureCeraphUrlScheme(projectDir);
+    let instructions;
+    if (action.kind === "expo-config-needs-manual") {
+        instructions = expoDynamicConfigInstructions(action.path);
+    }
+    else if (action.kind === "bare-rn-needs-manual") {
+        instructions = bareRnInstructions();
+    }
+    return { action, instructions };
+}
+const CAMERA_IMAGES_README_CONTENT = `# Ceraph camera test images
+
+Per-screen test images for \`<CeraphCamera />\` from
+\`@ceraph/react-native-mcp/shim\`. Three valid imageKey shapes:
+
+- \`<CeraphCamera />\` (no imageKey) → uninitialized; the bundled
+  1024x1024 black PNG renders. \`rn_preflight\` lists these so the
+  agent prompts you to pick a deliberate value.
+- \`imageKey="default"\` → explicit acknowledgment of the bundled
+  black PNG. Best when image content doesn't matter (most form /
+  upload / permission flows).
+- \`imageKey="<scenario>"\` → a file in this folder. Drop
+  \`<scenario>.{jpg,png,webp,heic}\` here.
+- \`imageKey="@runtime"\` → the flow planner picks the image
+  per-step at test time. Use for cameras that serve multiple
+  scenarios across flows.
+
+## Naming
+
+Lowercase + hyphen-separated, descriptive of what the image represents:
+
+- \`profile.jpg\` — face photo for a profile picture screen
+- \`id-card.png\` — government-issued ID for a KYC scan screen
+- \`product-photo.jpg\` — a product image for an upload screen
+
+Supported extensions: \`.jpg\`, \`.jpeg\`, \`.png\`, \`.webp\`, \`.heic\`.
+Extension priority on collision: jpg > jpeg > png > webp > heic.
+`;
+export async function setupImagesDir(projectDir) {
+    const dir = join(projectDir, ".ceraph", "camera-images");
+    await mkdir(dir, { recursive: true });
+    const readmePath = join(dir, "README.md");
+    const readmeWritten = !(await fileExists(readmePath));
+    if (readmeWritten) {
+        await writeFile(readmePath, CAMERA_IMAGES_README_CONTENT, "utf-8");
+    }
+    const gitignorePath = join(projectDir, ".gitignore");
+    let content = "";
+    try {
+        content = await readFile(gitignorePath, "utf-8");
+    }
+    catch {
+    }
+    const entries = [".rn-errors.json", ".rn-flow-progress.json", ".rn-mcp-cache/"];
+    const missing = entries.filter((e) => !content.includes(e));
+    let gitignoreUpdated = false;
+    if (missing.length > 0) {
+        const prefix = content === "" || content.endsWith("\n") ? "" : "\n";
+        await writeFile(gitignorePath, content + prefix + missing.join("\n") + "\n", "utf-8");
+        gitignoreUpdated = true;
+    }
+    return { dirPath: dir, readmeWritten, gitignoreUpdated };
+}
+const MCP_ENTRY = {
+    "mobile-mcp": {
+        command: "npx",
+        args: ["-y", "@mobilenext/mobile-mcp@latest"],
+    },
+    "react-native-mcp": {
+        command: "npx",
+        args: ["-y", "@ceraph/react-native-mcp@latest"],
+    },
+};
+export async function setupMcpClients(projectDir) {
+    const written = [];
+    const skipped = [];
+    const targets = [
+        { name: "Claude Code", path: join(projectDir, ".mcp.json") },
+        { name: "Cursor", path: join(projectDir, ".cursor", "mcp.json") },
+        {
+            name: "Codex",
+            path: join(projectDir, ".codex", "config.toml"),
+            toml: true,
+        },
+        { name: "VS Code", path: join(projectDir, ".vscode", "mcp.json") },
+    ];
+    for (const t of targets) {
+        const did = t.toml
+            ? await setupCodexToml(t.path)
+            : await setupJsonMcp(t.path);
+        if (did)
+            written.push(t.name);
+        else
+            skipped.push(t.name);
+    }
+    return { written, skipped };
+}
+async function setupJsonMcp(configPath) {
+    const existing = await readJsonOrEmpty(configPath);
+    const servers = (existing.mcpServers ?? {});
+    if (servers["react-native-mcp"])
+        return false;
+    servers["mobile-mcp"] = MCP_ENTRY["mobile-mcp"];
+    servers["react-native-mcp"] = MCP_ENTRY["react-native-mcp"];
+    existing.mcpServers = servers;
+    await mkdir(join(configPath, ".."), { recursive: true });
+    await writeFile(configPath, JSON.stringify(existing, null, 2) + "\n", "utf-8");
+    return true;
+}
+async function setupCodexToml(configPath) {
+    let content = "";
+    try {
+        content = await readFile(configPath, "utf-8");
+    }
+    catch {
+    }
+    if (content.includes("react-native-mcp"))
+        return false;
+    const tomlBlock = `
+[mcp_servers.mobile-mcp]
+command = "npx"
+args = ["-y", "@mobilenext/mobile-mcp@latest"]
+
+[mcp_servers.react-native-mcp]
+command = "npx"
+args = ["-y", "@ceraph/react-native-mcp@latest"]
+`;
+    await mkdir(join(configPath, ".."), { recursive: true });
+    await writeFile(configPath, content + tomlBlock, "utf-8");
+    return true;
+}
+async function readJsonOrEmpty(path) {
+    try {
+        const raw = await readFile(path, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === "object") {
+            return parsed;
+        }
+    }
+    catch {
+    }
+    return {};
+}
+export async function preflightForMcp(projectDir, deps = {}) {
+    const screen = deps.screen ?? new ScreenManager(deps.target ? { targetResolver: deps.target } : {});
+    const apps = deps.apps ?? new AppLifecycle(screen, deps.target);
+    const autonomy = deps.autonomy ?? new DeviceAutonomy(screen);
+    const res = await runPreflight({
+        screen,
+        apps,
+        autonomy,
+        projectDir,
+        target: deps.target,
+        iproxyManager: deps.iproxyManager ?? null,
+    });
+    const passedCount = res.checks.filter((c) => c.ok).length;
+    return {
+        ok: res.ok,
+        passedCount,
+        totalCount: res.checks.length,
+        checks: res.checks,
+    };
+}
+export async function detectMonorepoStatus(projectDir) {
+    const detection = await detectMonorepoSubpackages(projectDir);
+    return {
+        isMonorepo: detection.isMonorepo,
+        rootIsRnApp: detection.rootIsRnApp,
+        matches: detection.matches,
+    };
+}
+async function fileExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export { syncCameraRegistry, relativeRegistryPath };

package/dist/init/url-scheme.d.ts

@@ -0,0 +1,42 @@
+export type SchemeAction = {
+    kind: "expo-json-added";
+    previousScheme: SchemeShape;
+    nextScheme: string[];
+    path: string;
+} | {
+    kind: "expo-json-already-registered";
+    scheme: SchemeShape;
+    path: string;
+} | {
+    kind: "expo-config-needs-manual";
+    path: string;
+} | {
+    kind: "bare-rn-needs-manual";
+} | {
+    kind: "no-rn-project";
+};
+export type SchemeShape = string | string[] | undefined;
+export interface UrlSchemeDeps {
+    readFile?: (p: string) => Promise<string>;
+    writeFile?: (p: string, content: string) => Promise<void>;
+    fileExists?: (p: string) => Promise<boolean>;
+}
+export declare const CERAPH_SCHEME = "ceraph";
+export declare function ensureCeraphUrlScheme(projectDir: string, deps?: UrlSchemeDeps): Promise<SchemeAction>;
+interface ParsedAppJson {
+    expo?: {
+        scheme?: SchemeShape;
+        [k: string]: unknown;
+    };
+    [k: string]: unknown;
+}
+interface InjectResult {
+    action: "added" | "already";
+    scheme: SchemeShape;
+    previousScheme: SchemeShape;
+    nextScheme: string[];
+}
+export declare function injectSchemeIntoAppJson(parsed: ParsedAppJson, schemeToAdd: string): InjectResult;
+export declare function bareRnInstructions(): string;
+export declare function expoDynamicConfigInstructions(configPath: string): string;
+export {};