@ceraph/react-native-mcp 0.2.2 → 0.3.1

package/dist/uninstall/revert-camera.js

@@ -0,0 +1,199 @@
+import { writeFile, readdir } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+import { IndentationText, Node, Project, SyntaxKind, } from "ts-morph";
+const SHIM_MODULE = "@ceraph/react-native-mcp/shim";
+const SHIM_NAMED = "CeraphCamera";
+const EXPO_MODULE = "expo-camera";
+const EXPO_NAMED = "CameraView";
+const SCAN_ROOTS = ["app", "src", "screens"];
+const SCAN_EXTENSIONS = new Set([".tsx", ".jsx"]);
+const SKIP_DIRS = new Set([
+    "node_modules",
+    "dist",
+    "build",
+    ".git",
+    ".ceraph",
+    ".rn-mcp-cache",
+    ".expo",
+    ".next",
+    "ios",
+    "android",
+]);
+async function listCandidateFiles(projectDir) {
+    const out = [];
+    async function walk(dir) {
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const abs = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (SKIP_DIRS.has(entry.name))
+                    continue;
+                await walk(abs);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            const dot = entry.name.lastIndexOf(".");
+            if (dot < 0)
+                continue;
+            const ext = entry.name.slice(dot).toLowerCase();
+            if (!SCAN_EXTENSIONS.has(ext))
+                continue;
+            out.push(abs);
+        }
+    }
+    for (const sub of SCAN_ROOTS) {
+        await walk(join(projectDir, sub));
+    }
+    for (const candidate of ["App.tsx", "App.jsx"]) {
+        out.push(join(projectDir, candidate));
+    }
+    return out;
+}
+function buildProject(filePaths) {
+    const project = new Project({
+        useInMemoryFileSystem: false,
+        skipAddingFilesFromTsConfig: true,
+        skipFileDependencyResolution: true,
+        skipLoadingLibFiles: true,
+        compilerOptions: { allowJs: true, jsx: 1 },
+        manipulationSettings: { indentationText: IndentationText.TwoSpaces },
+    });
+    for (const path of filePaths) {
+        try {
+            project.addSourceFileAtPath(path);
+        }
+        catch {
+        }
+    }
+    return project;
+}
+function listJsxByName(source, name) {
+    const out = [];
+    source.forEachDescendant((node) => {
+        if (Node.isJsxOpeningElement(node) || Node.isJsxSelfClosingElement(node)) {
+            const tag = node.getTagNameNode();
+            if (tag.getText() === name) {
+                out.push(node);
+            }
+        }
+    });
+    return out;
+}
+function removeImageKeyAttribute(node) {
+    const attrs = node.getAttributes();
+    for (const attr of attrs) {
+        if (Node.isJsxAttribute(attr)) {
+            const nameNode = attr.getNameNode();
+            if (nameNode.getText() === "imageKey") {
+                attr.remove();
+            }
+        }
+    }
+}
+function renameCeraphCamerasToCameraView(source) {
+    let count = 0;
+    for (let safety = 0; safety < 10_000; safety++) {
+        const tags = listJsxByName(source, SHIM_NAMED);
+        if (tags.length === 0)
+            break;
+        const target = tags[0];
+        target.getTagNameNode().replaceWithText(EXPO_NAMED);
+        if (Node.isJsxOpeningElement(target)) {
+            const parent = target.getParentIfKind(SyntaxKind.JsxElement);
+            if (parent) {
+                const closing = parent.getClosingElement();
+                closing.getTagNameNode().replaceWithText(EXPO_NAMED);
+            }
+        }
+        removeImageKeyAttribute(target);
+        count++;
+    }
+    return count;
+}
+function dropCeraphCameraFromShimImport(source) {
+    const decl = source.getImportDeclaration(SHIM_MODULE);
+    if (!decl)
+        return false;
+    const named = decl.getNamedImports();
+    const target = named.find((n) => n.getName() === SHIM_NAMED);
+    if (!target)
+        return false;
+    target.remove();
+    const remaining = decl.getNamedImports();
+    const hasDefault = decl.getDefaultImport() != null;
+    if (remaining.length === 0 && !hasDefault) {
+        decl.remove();
+    }
+    return true;
+}
+function ensureCameraViewImport(source) {
+    const decl = source.getImportDeclaration(EXPO_MODULE);
+    if (decl) {
+        const named = decl.getNamedImports();
+        if (named.some((n) => n.getName() === EXPO_NAMED))
+            return false;
+        decl.addNamedImport(EXPO_NAMED);
+        return true;
+    }
+    source.addImportDeclaration({
+        moduleSpecifier: EXPO_MODULE,
+        namedImports: [EXPO_NAMED],
+    });
+    return true;
+}
+export async function revertCamera(projectDir) {
+    const candidates = await listCandidateFiles(projectDir);
+    const project = buildProject(candidates);
+    const files = [];
+    let filesScanned = 0;
+    for (const source of project.getSourceFiles()) {
+        filesScanned++;
+        const tags = listJsxByName(source, SHIM_NAMED);
+        if (tags.length === 0) {
+            const importDecl = source.getImportDeclaration(SHIM_MODULE);
+            const hasOrphanImport = importDecl != null &&
+                importDecl.getNamedImports().some((n) => n.getName() === SHIM_NAMED);
+            if (!hasOrphanImport)
+                continue;
+            const dropped = dropCeraphCameraFromShimImport(source);
+            if (!dropped)
+                continue;
+            const filePath = source.getFilePath();
+            await writeFile(filePath, source.getFullText(), "utf-8");
+            files.push({
+                path: filePath,
+                relPath: relative(projectDir, filePath).split(sep).join("/"),
+                ceraphCamerasRemoved: 0,
+                importDropped: true,
+                importRestored: false,
+            });
+            continue;
+        }
+        const ceraphCamerasRemoved = renameCeraphCamerasToCameraView(source);
+        const remainingShimTags = listJsxByName(source, SHIM_NAMED);
+        const importDropped = remainingShimTags.length === 0
+            ? dropCeraphCameraFromShimImport(source)
+            : false;
+        const hasCameraViewJsx = listJsxByName(source, EXPO_NAMED).length > 0;
+        const importRestored = hasCameraViewJsx
+            ? ensureCameraViewImport(source)
+            : false;
+        const filePath = source.getFilePath();
+        await writeFile(filePath, source.getFullText(), "utf-8");
+        files.push({
+            path: filePath,
+            relPath: relative(projectDir, filePath).split(sep).join("/"),
+            ceraphCamerasRemoved,
+            importDropped,
+            importRestored,
+        });
+    }
+    return { files, filesScanned };
+}

package/dist/uninstall/revert-ceraph-dir.d.ts

@@ -0,0 +1,27 @@
+export type RevertCeraphDirResult = {
+    status: "skipped-needs-confirmation";
+    path: string;
+    paths: string[];
+} | {
+    status: "deleted";
+    path: string;
+    deletedEntries: string[];
+} | {
+    status: "already-reverted";
+    path: string;
+};
+export interface RevertCeraphDirInput {
+    projectDir: string;
+    confirm: boolean;
+}
+export interface RevertCeraphDirDeps {
+    rm?: (p: string, opts: {
+        recursive: true;
+        force: true;
+    }) => Promise<void>;
+    readdir?: (p: string) => Promise<string[]>;
+    stat?: (p: string) => Promise<{
+        isDirectory: () => boolean;
+    }>;
+}
+export declare function revertCeraphDir(input: RevertCeraphDirInput, deps?: RevertCeraphDirDeps): Promise<RevertCeraphDirResult>;

package/dist/uninstall/revert-ceraph-dir.js

@@ -0,0 +1,38 @@
+import { rm, readdir, stat } from "node:fs/promises";
+import { join } from "node:path";
+async function dirExists(path, statFn) {
+    try {
+        const s = await statFn(path);
+        return s.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+export async function revertCeraphDir(input, deps = {}) {
+    const ceraphPath = join(input.projectDir, ".ceraph");
+    const rmFn = deps.rm ?? ((p, o) => rm(p, o));
+    const readdirFn = deps.readdir ?? ((p) => readdir(p));
+    const statFn = deps.stat ?? ((p) => stat(p));
+    const exists = await dirExists(ceraphPath, statFn);
+    if (!exists) {
+        return { status: "already-reverted", path: ceraphPath };
+    }
+    let entries = [];
+    try {
+        entries = await readdirFn(ceraphPath);
+    }
+    catch {
+        entries = [];
+    }
+    entries.sort();
+    if (!input.confirm) {
+        return {
+            status: "skipped-needs-confirmation",
+            path: ceraphPath,
+            paths: entries.map((e) => join(ceraphPath, e)),
+        };
+    }
+    await rmFn(ceraphPath, { recursive: true, force: true });
+    return { status: "deleted", path: ceraphPath, deletedEntries: entries };
+}

package/dist/uninstall/revert-claude-hooks.d.ts

@@ -0,0 +1,19 @@
+export type RevertClaudeHooksStatus = "reverted" | "already-reverted" | "manual" | "skipped";
+export interface RevertClaudeHooksResult {
+    status: RevertClaudeHooksStatus;
+    details: {
+        scriptsDeleted: string[];
+        scriptsLeftAlone: string[];
+        settingsFilesModified: string[];
+        settingsFilesUntouched: string[];
+    };
+}
+export interface RevertClaudeHooksDeps {
+    readFile?: (p: string) => Promise<string>;
+    writeFile?: (p: string, c: string) => Promise<void>;
+    unlink?: (p: string) => Promise<void>;
+    fileExists?: (p: string) => Promise<boolean>;
+}
+export declare function revertClaudeHooks(input: {
+    projectDir: string;
+}, deps?: RevertClaudeHooksDeps): Promise<RevertClaudeHooksResult>;

package/dist/uninstall/revert-claude-hooks.js

@@ -0,0 +1,191 @@
+import { access, readFile, unlink } from "node:fs/promises";
+import { join } from "node:path";
+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, HOOK_SCRIPT, FLOW_PROGRESS_HOOK_SCRIPT, } from "../init/claude-hook-constants.js";
+import { writeFileAtomic } from "../utils/atomic-write.js";
+async function defaultExists(p) {
+    try {
+        await access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function revertClaudeHooks(input, deps = {}) {
+    const read = deps.readFile ?? ((p) => readFile(p, "utf-8"));
+    const write = deps.writeFile ?? writeFileAtomic;
+    const unlinkFn = deps.unlink ?? ((p) => unlink(p));
+    const exists = deps.fileExists ?? defaultExists;
+    const hooks = [
+        {
+            scriptAbsPath: join(input.projectDir, ...ERROR_HOOK_REL_PATH),
+            canonicalScript: HOOK_SCRIPT,
+            matcher: ERROR_HOOK_MATCHER,
+            command: ERROR_HOOK_COMMAND,
+        },
+        {
+            scriptAbsPath: join(input.projectDir, ...FLOW_PROGRESS_HOOK_REL_PATH),
+            canonicalScript: FLOW_PROGRESS_HOOK_SCRIPT,
+            matcher: FLOW_PROGRESS_HOOK_MATCHER,
+            command: FLOW_PROGRESS_HOOK_COMMAND,
+        },
+    ];
+    const scriptsDeleted = [];
+    const scriptsLeftAlone = [];
+    for (const h of hooks) {
+        if (!(await exists(h.scriptAbsPath)))
+            continue;
+        let onDisk;
+        try {
+            onDisk = await read(h.scriptAbsPath);
+        }
+        catch {
+            scriptsLeftAlone.push(h.scriptAbsPath);
+            continue;
+        }
+        if (onDisk === h.canonicalScript) {
+            await unlinkFn(h.scriptAbsPath);
+            scriptsDeleted.push(h.scriptAbsPath);
+        }
+        else {
+            scriptsLeftAlone.push(h.scriptAbsPath);
+        }
+    }
+    const settingsFilesModified = [];
+    const settingsFilesUntouched = [];
+    for (const relParts of CLAUDE_SETTINGS_REL_PATHS) {
+        const abs = join(input.projectDir, ...relParts);
+        if (!(await exists(abs)))
+            continue;
+        let raw;
+        try {
+            raw = await read(abs);
+        }
+        catch {
+            settingsFilesUntouched.push(abs);
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            settingsFilesUntouched.push(abs);
+            continue;
+        }
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            settingsFilesUntouched.push(abs);
+            continue;
+        }
+        const result = stripHooksFromSettings(parsed, hooks);
+        if (!result.mutated) {
+            settingsFilesUntouched.push(abs);
+            continue;
+        }
+        const indentMatch = raw.match(/\n(\s+)"/);
+        const indent = indentMatch?.[1] ?? "  ";
+        const hadTrailingNewline = raw.endsWith("\n");
+        const out = JSON.stringify(result.next, null, indent);
+        await write(abs, hadTrailingNewline ? out + "\n" : out);
+        settingsFilesModified.push(abs);
+    }
+    const anyAction = scriptsDeleted.length > 0 || settingsFilesModified.length > 0;
+    let status;
+    if (scriptsLeftAlone.length > 0) {
+        status = "manual";
+    }
+    else if (anyAction) {
+        status = "reverted";
+    }
+    else {
+        status = "already-reverted";
+    }
+    return {
+        status,
+        details: {
+            scriptsDeleted,
+            scriptsLeftAlone,
+            settingsFilesModified,
+            settingsFilesUntouched,
+        },
+    };
+}
+function stripHooksFromSettings(obj, managed) {
+    const hooksVal = obj.hooks;
+    if (!hooksVal || typeof hooksVal !== "object" || Array.isArray(hooksVal)) {
+        return { mutated: false, next: obj };
+    }
+    const hooks = hooksVal;
+    const fileChanged = hooks.FileChanged;
+    if (!Array.isArray(fileChanged)) {
+        return { mutated: false, next: obj };
+    }
+    const managedByMatcher = new Map();
+    for (const m of managed)
+        managedByMatcher.set(m.matcher, m);
+    const keptEntries = [];
+    let mutated = false;
+    for (const raw of fileChanged) {
+        if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+            keptEntries.push(raw);
+            continue;
+        }
+        const entry = raw;
+        const matcher = entry.matcher;
+        if (typeof matcher !== "string") {
+            keptEntries.push(raw);
+            continue;
+        }
+        const managedHook = managedByMatcher.get(matcher);
+        if (!managedHook) {
+            keptEntries.push(raw);
+            continue;
+        }
+        const innerList = entry.hooks;
+        if (!Array.isArray(innerList)) {
+            keptEntries.push(raw);
+            continue;
+        }
+        const keptInner = [];
+        let droppedAny = false;
+        for (const innerRaw of innerList) {
+            if (!innerRaw || typeof innerRaw !== "object" || Array.isArray(innerRaw)) {
+                keptInner.push(innerRaw);
+                continue;
+            }
+            const innerObj = innerRaw;
+            const cmd = innerObj.command;
+            if (typeof cmd === "string" && cmd === managedHook.command) {
+                droppedAny = true;
+                continue;
+            }
+            keptInner.push(innerRaw);
+        }
+        if (!droppedAny) {
+            keptEntries.push(raw);
+            continue;
+        }
+        mutated = true;
+        if (keptInner.length === 0) {
+            continue;
+        }
+        keptEntries.push({ ...entry, hooks: keptInner });
+    }
+    if (!mutated)
+        return { mutated: false, next: obj };
+    const nextHooks = { ...hooks };
+    if (keptEntries.length === 0) {
+        delete nextHooks.FileChanged;
+    }
+    else {
+        nextHooks.FileChanged = keptEntries;
+    }
+    const next = { ...obj };
+    if (Object.keys(nextHooks).length === 0) {
+        delete next.hooks;
+    }
+    else {
+        next.hooks = nextHooks;
+    }
+    return { mutated: true, next };
+}

package/dist/uninstall/revert-gitignore.d.ts

@@ -0,0 +1,17 @@
+export declare const GITIGNORE_ENTRIES: readonly [".rn-errors.json", ".rn-flow-progress.json", ".rn-mcp-cache/", ".rn-mcp-cache"];
+export type RevertGitignoreResult = {
+    status: "reverted";
+    path: string;
+    removedLines: string[];
+} | {
+    status: "already-reverted";
+    path: string;
+} | {
+    status: "no-gitignore";
+    path: string;
+};
+export interface RevertGitignoreDeps {
+    readFile?: (p: string) => Promise<string>;
+    writeFile?: (p: string, c: string) => Promise<void>;
+}
+export declare function revertGitignore(projectDir: string, deps?: RevertGitignoreDeps): Promise<RevertGitignoreResult>;

package/dist/uninstall/revert-gitignore.js

@@ -0,0 +1,43 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+export const GITIGNORE_ENTRIES = [
+    ".rn-errors.json",
+    ".rn-flow-progress.json",
+    ".rn-mcp-cache/",
+    ".rn-mcp-cache",
+];
+export async function revertGitignore(projectDir, deps = {}) {
+    const path = join(projectDir, ".gitignore");
+    const read = deps.readFile ?? ((p) => readFile(p, "utf-8"));
+    const write = deps.writeFile ?? ((p, c) => writeFile(p, c, "utf-8"));
+    let content;
+    try {
+        content = await read(path);
+    }
+    catch {
+        return { status: "no-gitignore", path };
+    }
+    const hadTrailingNewline = content.endsWith("\n");
+    const lines = content.split(/\r?\n/);
+    if (hadTrailingNewline && lines.length > 0 && lines[lines.length - 1] === "") {
+        lines.pop();
+    }
+    const targets = new Set(GITIGNORE_ENTRIES);
+    const removedLines = [];
+    const kept = [];
+    for (const line of lines) {
+        if (targets.has(line.trim())) {
+            removedLines.push(line);
+            continue;
+        }
+        kept.push(line);
+    }
+    if (removedLines.length === 0) {
+        return { status: "already-reverted", path };
+    }
+    const nextContent = hadTrailingNewline
+        ? kept.join("\n") + "\n"
+        : kept.join("\n");
+    await write(path, nextContent);
+    return { status: "reverted", path, removedLines };
+}

package/dist/uninstall/revert-mcp-clients.d.ts

@@ -0,0 +1,57 @@
+export declare const JSON_CLIENT_PATHS: readonly [".mcp.json", string, string];
+export declare const TOML_CLIENT_PATHS: readonly [string];
+export interface UserGlobalMcpClient {
+    label: string;
+    dir: readonly string[];
+    file: readonly string[];
+}
+export declare const USER_GLOBAL_MCP_CLIENTS: readonly UserGlobalMcpClient[];
+export declare function userGlobalMcpClientPaths(home?: string): Array<{
+    label: string;
+    path: string;
+}>;
+export declare const SERVER_KEYS: readonly ["mobile-mcp", "react-native-mcp"];
+export type RevertMcpClientFileResult = {
+    path: string;
+    status: "removed-entries";
+    removedKeys: string[];
+} | {
+    path: string;
+    status: "deleted-file";
+    removedKeys: string[];
+} | {
+    path: string;
+    status: "no-changes";
+} | {
+    path: string;
+    status: "not-found";
+} | {
+    path: string;
+    status: "malformed";
+};
+export interface RevertMcpClientsResult {
+    files: RevertMcpClientFileResult[];
+}
+export interface RevertMcpClientsDeps {
+    readFile?: (p: string) => Promise<string>;
+    writeFile?: (p: string, c: string) => Promise<void>;
+    unlink?: (p: string) => Promise<void>;
+    fileExists?: (p: string) => Promise<boolean>;
+}
+export declare function revertMcpClients(projectDir: string, deps?: RevertMcpClientsDeps): Promise<RevertMcpClientsResult>;
+declare function stripTomlSections(raw: string, sectionHeadings: ReadonlySet<string>): {
+    next: string;
+    removedKeys: string[];
+};
+export { stripTomlSections };
+export interface RevertUserGlobalMcpClientsResult {
+    files: RevertMcpClientFileResult[];
+}
+export interface RevertUserGlobalMcpClientsDeps {
+    readFile?: (p: string) => Promise<string>;
+    writeFile?: (p: string, c: string) => Promise<void>;
+    unlink?: (p: string) => Promise<void>;
+    fileExists?: (p: string) => Promise<boolean>;
+    home?: string;
+}
+export declare function revertUserGlobalMcpClients(deps?: RevertUserGlobalMcpClientsDeps): Promise<RevertUserGlobalMcpClientsResult>;