@ceraph/react-native-mcp 0.2.2 → 0.3.2

package/dist/uninstall/cli-runner.js

@@ -0,0 +1,223 @@
+import { spawn } from "node:child_process";
+import { stat } from "node:fs/promises";
+import { join } from "node:path";
+import { confirm, print } from "../init/prompt.js";
+import { runUninstallWalkthrough, } from "./walkthrough.js";
+const USAGE = `Usage: npx @ceraph/react-native-mcp uninstall [flags]
+
+Removes Ceraph from the current React Native / Expo project. By default:
+- Reverts source-tree edits (CameraView, layout boot, ceraph URL scheme)
+- Strips MCP client configs (.mcp.json, .cursor/, .vscode/, .codex/)
+- Removes gitignore entries
+- Removes CERAPH_SIGNAL_HOST from your shell rc
+- Removes @ceraph/react-native-mcp from package.json
+- LEAVES .ceraph/ (test images, design snapshots) in place
+- LEAVES ~/.ceraph/auth.json in place (token is user-global)
+
+Flags:
+  -y, --yes              Skip confirmation prompts.
+      --purge-images     Also delete .ceraph/ (camera images + snapshots).
+      --global           Also delete ~/.ceraph/auth.json (logs you out of
+                         every Ceraph install on this machine).
+      --dry-run          Preview the revert without mutating anything.
+      --project-dir <p>  Operate on this subpackage. Required when a
+                         monorepo has more than one RN app.
+  -h, --help             Print this help and exit.
+`;
+export async function runUninstallCli(opts) {
+    const flags = parseArgs(opts.argv);
+    if (flags.help) {
+        print(USAGE, opts);
+        return { exitCode: 0, walkthrough: null, parsedFlags: flags };
+    }
+    if (flags.unknown.length > 0) {
+        print(`Unknown flag(s): ${flags.unknown.join(", ")}\n\n${USAGE}`, opts);
+        return { exitCode: 1, walkthrough: null, parsedFlags: flags };
+    }
+    const projectDir = flags.projectDir ?? opts.cwd ?? process.cwd();
+    if (flags.projectDir != null) {
+        const validation = await validateProjectDir(flags.projectDir);
+        if (validation !== null) {
+            print(`${validation}\n`, opts);
+            return { exitCode: 1, walkthrough: null, parsedFlags: flags };
+        }
+    }
+    let purgeImages = flags.purgeImages;
+    let global = flags.global;
+    if (!flags.yes && !flags.dryRun) {
+        print(`\n@ceraph/react-native-mcp uninstall\n`, opts);
+        print(`  Project: ${projectDir}\n`, opts);
+        print(`  Mode:    live (no --dry-run)\n`, opts);
+        print(`  Default-safe: leaves .ceraph/ and ~/.ceraph/auth.json untouched.\n\n`, opts);
+        const proceed = await confirm("Continue with uninstall?", {
+            ...opts,
+            defaultYes: false,
+        });
+        if (!proceed) {
+            print(`\nAborted — no changes made.\n`, opts);
+            return { exitCode: 0, walkthrough: null, parsedFlags: flags };
+        }
+        if (!purgeImages) {
+            purgeImages = await confirm("Also purge camera images + snapshots at .ceraph/?", { ...opts, defaultYes: false });
+        }
+        if (!global) {
+            global = await confirm("Also sign out (delete ~/.ceraph/auth.json)?", { ...opts, defaultYes: false });
+        }
+    }
+    if (flags.dryRun) {
+        print(`\n@ceraph/react-native-mcp uninstall — dry-run preview\n`, opts);
+        print(`  Project: ${projectDir}\n\n`, opts);
+    }
+    const walkthrough = await runUninstallWalkthrough({
+        projectDir,
+        purgeImages,
+        global,
+        dryRun: flags.dryRun,
+        nonInteractive: flags.yes,
+        spawnRemove: opts.spawnRemove ?? defaultSpawnRemove,
+        onStep: (step) => {
+            print(formatStepLine(step), opts);
+        },
+    });
+    print(formatSummary(walkthrough), opts);
+    const hasError = walkthrough.steps.some((s) => s.status === "error" || s.status === "manual");
+    return {
+        exitCode: hasError ? 1 : 0,
+        walkthrough,
+        parsedFlags: { ...flags, purgeImages, global },
+    };
+}
+export function formatStepLine(step) {
+    const icon = iconFor(step.status);
+    const summary = summaryFor(step);
+    return `  ${icon} ${step.name.padEnd(13)} ${summary}\n`;
+}
+function iconFor(status) {
+    switch (status) {
+        case "reverted":
+            return "[ok]";
+        case "already-reverted":
+            return "[--]";
+        case "skipped":
+            return "[--]";
+        case "warning":
+            return "[!]";
+        case "manual":
+            return "[!]";
+        case "error":
+            return "[X]";
+    }
+}
+function summaryFor(step) {
+    switch (step.status) {
+        case "reverted":
+            return `reverted${step.details?.dryRun ? " (preview)" : ""}`;
+        case "already-reverted":
+            return `nothing to do${step.details?.dryRun ? " (preview)" : ""}`;
+        case "skipped":
+            return `skipped — ${step.remediation ?? "gate closed"}`;
+        case "warning":
+            return `reverted with warning — ${step.remediation ?? ""}`;
+        case "manual":
+            return `manual action required — ${step.remediation ?? ""}`;
+        case "error":
+            return `error — ${step.remediation ?? step.details?.error ?? "see details"}`;
+    }
+}
+export function formatSummary(result) {
+    const { reverted, skipped, warnings, manualSteps } = result.summary;
+    const lines = ["\nSummary:\n"];
+    lines.push(`  Reverted:        ${reverted}\n`);
+    lines.push(`  Skipped/no-op:   ${skipped}\n`);
+    lines.push(`  Warnings:        ${warnings.length}\n`);
+    lines.push(`  Manual actions:  ${manualSteps.length}\n`);
+    if (warnings.length > 0) {
+        lines.push(`\nWarnings:\n`);
+        for (const w of warnings)
+            lines.push(`  - ${w}\n`);
+    }
+    if (manualSteps.length > 0) {
+        lines.push(`\nManual actions needed:\n`);
+        for (const m of manualSteps)
+            lines.push(`  - ${m}\n`);
+    }
+    return lines.join("");
+}
+export function parseArgs(argv) {
+    const flags = {
+        yes: false,
+        purgeImages: false,
+        global: false,
+        dryRun: false,
+        projectDir: null,
+        help: false,
+        unknown: [],
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        switch (arg) {
+            case "-y":
+            case "--yes":
+                flags.yes = true;
+                break;
+            case "--purge-images":
+                flags.purgeImages = true;
+                break;
+            case "--global":
+                flags.global = true;
+                break;
+            case "--dry-run":
+                flags.dryRun = true;
+                break;
+            case "--project-dir": {
+                const next = argv[i + 1];
+                if (next == null) {
+                    flags.unknown.push(`${arg} (missing value)`);
+                }
+                else {
+                    flags.projectDir = next;
+                    i++;
+                }
+                break;
+            }
+            case "-h":
+            case "--help":
+                flags.help = true;
+                break;
+            default:
+                if (arg !== undefined)
+                    flags.unknown.push(arg);
+        }
+    }
+    return flags;
+}
+async function validateProjectDir(path) {
+    let entryStat;
+    try {
+        entryStat = await stat(path);
+    }
+    catch {
+        return `Error: --project-dir does not exist: ${path}`;
+    }
+    if (!entryStat.isDirectory()) {
+        return `Error: --project-dir is not a directory: ${path}`;
+    }
+    try {
+        await stat(join(path, "package.json"));
+    }
+    catch {
+        return (`Error: --project-dir does not look like an npm/RN project ` +
+            `(no package.json at ${join(path, "package.json")})`);
+    }
+    return null;
+}
+function defaultSpawnRemove(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 }));
+    });
+}

package/dist/uninstall/footprint.d.ts

@@ -0,0 +1,40 @@
+import { detectMonorepoSubpackages } from "../init/monorepo.js";
+import { type PackageManager } from "./revert-package.js";
+export interface InstalledFootprint {
+    workingDir: string;
+    monorepoConflict: {
+        matches: Array<{
+            relPath: string;
+            absPath: string;
+        }>;
+    } | null;
+    packageInstalled: boolean;
+    packageManager: PackageManager;
+    appiumPresent: boolean;
+    gitignoreEntriesPresent: boolean;
+    gitignoreEntries: string[];
+    schemeRegistered: boolean | null;
+    bootTargetPath: string | null;
+    bootInjected: boolean | null;
+    ceraphCameraUsageCount: number;
+    mcpClientsConfigured: {
+        claudeCode: boolean;
+        cursor: boolean;
+        codex: boolean;
+        vscode: boolean;
+        windsurf: boolean;
+        antigravity: boolean;
+    };
+    claudeHooksPresent: {
+        errorScript: boolean;
+        flowProgressScript: boolean;
+        settingsEntries: boolean;
+    };
+    ceraphDirPresent: boolean;
+    authPresent: boolean;
+}
+export interface FootprintDeps {
+    homeDir?: () => string;
+    detectMonorepo?: typeof detectMonorepoSubpackages;
+}
+export declare function getInstalledFootprint(projectDir: string, deps?: FootprintDeps): Promise<InstalledFootprint>;

package/dist/uninstall/footprint.js

@@ -0,0 +1,288 @@
+import { access, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { detectMonorepoSubpackages } from "../init/monorepo.js";
+import { detectPackageManager, } from "./revert-package.js";
+import { detectRevertTarget } from "./revert-boot.js";
+import { userGlobalMcpClientPaths } from "./revert-mcp-clients.js";
+import { CLAUDE_SETTINGS_REL_PATHS, ERROR_HOOK_COMMAND, ERROR_HOOK_MATCHER, ERROR_HOOK_REL_PATH, FLOW_PROGRESS_HOOK_COMMAND, FLOW_PROGRESS_HOOK_MATCHER, FLOW_PROGRESS_HOOK_REL_PATH, } from "../init/claude-hook-constants.js";
+async function fileExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readPackageJson(projectDir) {
+    try {
+        const raw = await readFile(join(projectDir, "package.json"), "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+async function detectGitignoreEntries(projectDir) {
+    const path = join(projectDir, ".gitignore");
+    let content;
+    try {
+        content = await readFile(path, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    const TARGETS = [
+        ".rn-errors.json",
+        ".rn-flow-progress.json",
+        ".rn-mcp-cache/",
+        ".rn-mcp-cache",
+    ];
+    return TARGETS.filter((t) => content.split(/\r?\n/).some((line) => line.trim() === t));
+}
+async function detectSchemeRegistered(projectDir) {
+    const appJsonPath = join(projectDir, "app.json");
+    let raw;
+    try {
+        raw = await readFile(appJsonPath, "utf-8");
+    }
+    catch {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    const scheme = parsed.expo?.scheme;
+    if (typeof scheme === "string")
+        return scheme === "ceraph";
+    if (Array.isArray(scheme))
+        return scheme.includes("ceraph");
+    return false;
+}
+async function countCeraphCameraUsages(projectDir) {
+    const SCAN_ROOTS = ["app", "src", "screens"];
+    const SCAN_EXT = new Set([".tsx", ".jsx"]);
+    const SKIP_DIRS = new Set([
+        "node_modules",
+        "dist",
+        "build",
+        ".git",
+        ".ceraph",
+        ".rn-mcp-cache",
+        ".expo",
+        ".next",
+        "ios",
+        "android",
+    ]);
+    let count = 0;
+    const walk = async (dir) => {
+        let entries;
+        try {
+            const { readdir } = await import("node:fs/promises");
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                if (SKIP_DIRS.has(entry.name))
+                    continue;
+                await walk(join(dir, entry.name));
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            const dot = entry.name.lastIndexOf(".");
+            if (dot < 0)
+                continue;
+            const ext = entry.name.slice(dot).toLowerCase();
+            if (!SCAN_EXT.has(ext))
+                continue;
+            try {
+                const raw = await readFile(join(dir, entry.name), "utf-8");
+                const matches = raw.match(/<CeraphCamera/g);
+                if (matches)
+                    count += matches.length;
+            }
+            catch {
+            }
+        }
+    };
+    for (const root of SCAN_ROOTS) {
+        await walk(join(projectDir, root));
+    }
+    for (const single of ["App.tsx", "App.jsx"]) {
+        try {
+            const raw = await readFile(join(projectDir, single), "utf-8");
+            const matches = raw.match(/<CeraphCamera/g);
+            if (matches)
+                count += matches.length;
+        }
+        catch {
+        }
+    }
+    return count;
+}
+async function detectMcpClientConfigured(projectDir, home) {
+    const hasEntry = async (path, kind) => {
+        try {
+            const raw = await readFile(path, "utf-8");
+            if (kind === "json") {
+                const parsed = JSON.parse(raw);
+                const servers = parsed.mcpServers ?? {};
+                return Boolean(servers["react-native-mcp"] || servers["mobile-mcp"]);
+            }
+            return (raw.includes("[mcp_servers.react-native-mcp]") ||
+                raw.includes("[mcp_servers.mobile-mcp]"));
+        }
+        catch {
+            return false;
+        }
+    };
+    const globals = userGlobalMcpClientPaths(home || undefined);
+    const byLabel = {};
+    for (const g of globals)
+        byLabel[g.label] = g.path;
+    return {
+        claudeCode: await hasEntry(join(projectDir, ".mcp.json"), "json"),
+        cursor: await hasEntry(join(projectDir, ".cursor", "mcp.json"), "json"),
+        codex: await hasEntry(join(projectDir, ".codex", "config.toml"), "toml"),
+        vscode: await hasEntry(join(projectDir, ".vscode", "mcp.json"), "json"),
+        windsurf: home
+            ? await hasEntry(byLabel.Windsurf ?? "", "json")
+            : false,
+        antigravity: home
+            ? await hasEntry(byLabel.Antigravity ?? "", "json")
+            : false,
+    };
+}
+async function detectClaudeHooksPresent(projectDir) {
+    const errorScript = await fileExists(join(projectDir, ...ERROR_HOOK_REL_PATH));
+    const flowProgressScript = await fileExists(join(projectDir, ...FLOW_PROGRESS_HOOK_REL_PATH));
+    let settingsEntries = false;
+    for (const relParts of CLAUDE_SETTINGS_REL_PATHS) {
+        const abs = join(projectDir, ...relParts);
+        let raw;
+        try {
+            raw = await readFile(abs, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            continue;
+        }
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            continue;
+        const hooks = parsed.hooks;
+        if (!hooks || typeof hooks !== "object" || Array.isArray(hooks))
+            continue;
+        const fc = hooks.FileChanged;
+        if (!Array.isArray(fc))
+            continue;
+        for (const entry of fc) {
+            if (!entry || typeof entry !== "object" || Array.isArray(entry))
+                continue;
+            const e = entry;
+            const matcher = e.matcher;
+            if (matcher !== ERROR_HOOK_MATCHER && matcher !== FLOW_PROGRESS_HOOK_MATCHER) {
+                continue;
+            }
+            const ourCommand = matcher === ERROR_HOOK_MATCHER
+                ? ERROR_HOOK_COMMAND
+                : FLOW_PROGRESS_HOOK_COMMAND;
+            const list = e.hooks;
+            if (!Array.isArray(list))
+                continue;
+            for (const raw2 of list) {
+                if (!raw2 || typeof raw2 !== "object" || Array.isArray(raw2))
+                    continue;
+                const cmd = raw2.command;
+                if (typeof cmd === "string" && cmd === ourCommand) {
+                    settingsEntries = true;
+                    break;
+                }
+            }
+            if (settingsEntries)
+                break;
+        }
+        if (settingsEntries)
+            break;
+    }
+    return { errorScript, flowProgressScript, settingsEntries };
+}
+export async function getInstalledFootprint(projectDir, deps = {}) {
+    const detect = deps.detectMonorepo ?? detectMonorepoSubpackages;
+    const detection = await detect(projectDir);
+    let workingDir = projectDir;
+    let monorepoConflict = null;
+    if (detection.kind === "single" && detection.matches[0]) {
+        workingDir = detection.matches[0].absPath;
+    }
+    else if (detection.kind === "multi") {
+        monorepoConflict = {
+            matches: detection.matches.map((m) => ({
+                relPath: m.relPath,
+                absPath: m.absPath,
+            })),
+        };
+    }
+    const home = deps.homeDir?.() ??
+        process.env.HOME ??
+        process.env.USERPROFILE ??
+        "";
+    const pkg = await readPackageJson(workingDir);
+    const allDeps = {
+        ...(pkg?.dependencies ?? {}),
+        ...(pkg?.devDependencies ?? {}),
+    };
+    const packageInstalled = Boolean(allDeps["@ceraph/react-native-mcp"]);
+    const appiumPresent = Boolean(allDeps["appium-webdriveragent"]);
+    const packageManager = await detectPackageManager(workingDir);
+    const gitignoreEntries = await detectGitignoreEntries(workingDir);
+    const schemeRegistered = await detectSchemeRegistered(workingDir);
+    const bootTarget = await detectRevertTarget(workingDir);
+    let bootInjected = null;
+    if (bootTarget) {
+        try {
+            const raw = await readFile(bootTarget.filePath, "utf-8");
+            bootInjected = raw.includes("installCeraph(");
+        }
+        catch {
+            bootInjected = null;
+        }
+    }
+    const ceraphCameraUsageCount = await countCeraphCameraUsages(workingDir);
+    const mcpClientsConfigured = await detectMcpClientConfigured(workingDir, home);
+    const claudeHooksPresent = await detectClaudeHooksPresent(workingDir);
+    const ceraphDirPresent = await fileExists(join(workingDir, ".ceraph"));
+    const authPresent = home
+        ? await fileExists(join(home, ".ceraph", "auth.json"))
+        : false;
+    return {
+        workingDir,
+        monorepoConflict,
+        packageInstalled,
+        packageManager,
+        appiumPresent,
+        gitignoreEntriesPresent: gitignoreEntries.length > 0,
+        gitignoreEntries,
+        schemeRegistered,
+        bootTargetPath: bootTarget?.filePath ?? null,
+        bootInjected,
+        ceraphCameraUsageCount,
+        mcpClientsConfigured,
+        claudeHooksPresent,
+        ceraphDirPresent,
+        authPresent,
+    };
+}

package/dist/uninstall/mcp-tools.d.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import { type UninstallWalkthroughResult } from "./walkthrough.js";
+interface RegisterServer {
+    tool: (name: string, description: string, schema: Record<string, z.ZodTypeAny>, handler: (args: Record<string, unknown>) => Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        isError?: true;
+    }>) => void;
+}
+export declare function compactWalkthroughResult(result: UninstallWalkthroughResult, maxBytes?: number): UninstallWalkthroughResult;
+export declare function registerUninstallTools(server: RegisterServer): void;
+export {};