@ceraph/react-native-mcp 0.2.2 → 0.3.2

package/dist/uninstall/mcp-tools.js

@@ -0,0 +1,175 @@
+import { spawn } from "node:child_process";
+import { z } from "zod";
+import { getInstalledFootprint } from "./footprint.js";
+import { runUninstallWalkthrough, } from "./walkthrough.js";
+const MAX_TOOL_PAYLOAD_BYTES = 64 * 1024;
+const MODULE_LOAD_CWD = process.cwd();
+function defaultCwd() {
+    return MODULE_LOAD_CWD;
+}
+function toolResult(payload) {
+    return {
+        content: [
+            { type: "text", text: JSON.stringify(payload, null, 2) },
+        ],
+    };
+}
+const MAX_STRING_FIELD_BYTES = 2 * 1024;
+function truncateString(s, max) {
+    if (s.length <= max)
+        return s;
+    const head = s.slice(0, Math.floor(max / 2) - 16);
+    const tail = s.slice(s.length - (Math.floor(max / 2) - 16));
+    return `${head} … <${s.length - max} bytes truncated> … ${tail}`;
+}
+export function compactWalkthroughResult(result, maxBytes = MAX_TOOL_PAYLOAD_BYTES) {
+    const full = JSON.stringify(result, null, 2);
+    if (full.length <= maxBytes)
+        return result;
+    const compactSteps = result.steps.map((step) => {
+        if (step.details === undefined)
+            return step;
+        const detailsJson = JSON.stringify(step.details);
+        return {
+            ...step,
+            details: {
+                truncated: true,
+                originalSize: detailsJson.length,
+            },
+        };
+    });
+    const afterPass1 = {
+        ...result,
+        steps: compactSteps,
+    };
+    const pass1Json = JSON.stringify(afterPass1, null, 2);
+    if (pass1Json.length <= maxBytes)
+        return afterPass1;
+    let lo = 32;
+    let hi = MAX_STRING_FIELD_BYTES;
+    let best = afterPass1;
+    while (lo <= hi) {
+        const mid = Math.floor((lo + hi) / 2);
+        const candidate = {
+            ...afterPass1,
+            workingDir: truncateString(afterPass1.workingDir, mid),
+            steps: afterPass1.steps.map((step) => ({
+                ...step,
+                remediation: step.remediation
+                    ? truncateString(step.remediation, mid)
+                    : step.remediation,
+            })),
+            summary: {
+                ...afterPass1.summary,
+                warnings: afterPass1.summary.warnings.map((w) => truncateString(w, mid)),
+                manualSteps: afterPass1.summary.manualSteps.map((m) => truncateString(m, mid)),
+            },
+        };
+        const size = JSON.stringify(candidate, null, 2).length;
+        if (size <= maxBytes) {
+            best = candidate;
+            lo = mid + 1;
+        }
+        else {
+            hi = mid - 1;
+        }
+    }
+    return best;
+}
+function toolError(toolName, err) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: `${toolName} failed: ${err instanceof Error ? err.message : String(err)}`,
+            },
+        ],
+        isError: true,
+    };
+}
+function bufferedSpawnRemove(input) {
+    return new Promise((resolve) => {
+        const child = spawn(input.bin, input.args, {
+            cwd: input.cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        child.stdout?.on("data", () => undefined);
+        child.stderr?.on("data", () => undefined);
+        child.on("error", () => resolve({ exitCode: 127 }));
+        child.on("exit", (code) => resolve({ exitCode: code ?? 1 }));
+    });
+}
+export function registerUninstallTools(server) {
+    server.tool("ceraph_uninstall_status", "Snapshot what Ceraph has installed in this project — package " +
+        "presence, gitignore entries, MCP-client configs, root-layout " +
+        "boot wiring, <CeraphCamera> usage count, and whether the user-" +
+        "global auth token is present. Use this BEFORE ceraph_uninstall_run " +
+        "to show the user what would change. Returns the footprint without " +
+        "mutating anything.", {
+        projectDir: z
+            .string()
+            .optional()
+            .describe("Project directory to inspect. Defaults to the MCP server's " +
+            "cwd. In a monorepo with multiple RN subpackages, the tool " +
+            "returns `monorepoConflict` listing each candidate — pass " +
+            "the chosen subpackage's path here to disambiguate."),
+    }, async (args) => {
+        try {
+            const projectDir = args.projectDir ?? defaultCwd();
+            const footprint = await getInstalledFootprint(projectDir);
+            return toolResult(footprint);
+        }
+        catch (err) {
+            return toolError("ceraph_uninstall_status", err);
+        }
+    });
+    server.tool("ceraph_uninstall_run", "Uninstall Ceraph from this project. Reverts source-tree edits " +
+        "(<CeraphCamera> → <CameraView>, installCeraph() boot wiring, " +
+        "ceraph URL scheme), strips MCP client configs, removes gitignore " +
+        "entries + the shell signal-host export, and uninstalls the " +
+        "package via the project's package manager. Default leaves " +
+        "`.ceraph/` (test images + snapshots) and `~/.ceraph/auth.json` " +
+        "(user-global OAuth token) untouched. Pass `purgeImages` and " +
+        "`global` to nuke those too. Always call with `dryRun: true` " +
+        "first to preview the step list before a real run.", {
+        projectDir: z
+            .string()
+            .optional()
+            .describe("Project directory to operate on. Defaults to the MCP " +
+            "server's cwd. Required to disambiguate monorepo " +
+            "multi-match."),
+        purgeImages: z
+            .boolean()
+            .optional()
+            .describe("If true, also delete `.ceraph/` (camera test images + " +
+            "design snapshots + run artifacts). Default false."),
+        global: z
+            .boolean()
+            .optional()
+            .describe("If true, also delete `~/.ceraph/auth.json` (the user-global " +
+            "OAuth token; this logs the user out of every Ceraph " +
+            "install on this machine). Default false."),
+        dryRun: z
+            .boolean()
+            .optional()
+            .describe("If true, return the step list as a preview without " +
+            "mutating anything. Use this first to show the user what " +
+            "would happen."),
+    }, async (args) => {
+        try {
+            const projectDir = args.projectDir ?? defaultCwd();
+            const result = await runUninstallWalkthrough({
+                projectDir,
+                purgeImages: args.purgeImages === true,
+                global: args.global === true,
+                dryRun: args.dryRun === true,
+                nonInteractive: true,
+                spawnRemove: bufferedSpawnRemove,
+            });
+            return toolResult(compactWalkthroughResult(result));
+        }
+        catch (err) {
+            return toolError("ceraph_uninstall_run", err);
+        }
+    });
+}

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

@@ -0,0 +1,22 @@
+export type RevertAuthResult = {
+    status: "skipped";
+    path: string;
+    note: string;
+} | {
+    status: "deleted";
+    path: string;
+} | {
+    status: "already-reverted";
+    path: string;
+};
+export interface RevertAuthInput {
+    global: boolean;
+}
+export interface RevertAuthDeps {
+    unlink?: (p: string) => Promise<void>;
+    home?: string;
+}
+export declare function authJsonPath(deps?: {
+    home?: string;
+}): string;
+export declare function revertAuth(input: RevertAuthInput, deps?: RevertAuthDeps): Promise<RevertAuthResult>;

package/dist/uninstall/revert-auth.js

@@ -0,0 +1,31 @@
+import { unlink } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+export function authJsonPath(deps = {}) {
+    return join(deps.home ?? homedir(), ".ceraph", "auth.json");
+}
+export async function revertAuth(input, deps = {}) {
+    const path = authJsonPath({ home: deps.home });
+    const unlinkFn = deps.unlink ?? ((p) => unlink(p));
+    if (!input.global) {
+        return {
+            status: "skipped",
+            path,
+            note: "Pass global: true to remove ~/.ceraph/auth.json — the token is user-global and removing it logs you out of every Ceraph install.",
+        };
+    }
+    try {
+        await unlinkFn(path);
+        return { status: "deleted", path };
+    }
+    catch (err) {
+        const isMissing = typeof err === "object" &&
+            err !== null &&
+            "code" in err &&
+            err.code === "ENOENT";
+        if (isMissing) {
+            return { status: "already-reverted", path };
+        }
+        throw err;
+    }
+}

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

@@ -0,0 +1,24 @@
+export type RevertBootTarget = {
+    kind: "expo-router";
+    filePath: string;
+} | {
+    kind: "bare-rn";
+    filePath: string;
+};
+export type RevertBootResult = {
+    status: "reverted";
+    target: RevertBootTarget;
+    removedUseEffect: boolean;
+    removedImport: boolean;
+} | {
+    status: "already-reverted";
+    target: RevertBootTarget;
+} | {
+    status: "skipped";
+    target: RevertBootTarget;
+    reason: string;
+} | {
+    status: "no-layout-found";
+};
+export declare function detectRevertTarget(projectDir: string): Promise<RevertBootTarget | null>;
+export declare function revertBoot(projectDir: string): Promise<RevertBootResult>;

package/dist/uninstall/revert-boot.js

@@ -0,0 +1,242 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { IndentationText, Node, Project, SyntaxKind, } from "ts-morph";
+const SHIM_MODULE = "@ceraph/react-native-mcp/shim";
+const INSTALL_CALL = "installCeraph";
+async function fileExists(path) {
+    try {
+        await readFile(path, "utf-8");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function detectRevertTarget(projectDir) {
+    const expo = join(projectDir, "app", "_layout.tsx");
+    if (await fileExists(expo)) {
+        return { kind: "expo-router", filePath: expo };
+    }
+    const expoJsx = join(projectDir, "app", "_layout.jsx");
+    if (await fileExists(expoJsx)) {
+        return { kind: "expo-router", filePath: expoJsx };
+    }
+    for (const name of ["App.tsx", "App.jsx"]) {
+        const p = join(projectDir, name);
+        if (await fileExists(p)) {
+            return { kind: "bare-rn", filePath: p };
+        }
+    }
+    return null;
+}
+function findDefaultExportFunction(source) {
+    for (const fn of source.getFunctions()) {
+        if (fn.isDefaultExport())
+            return fn;
+    }
+    const exportAssignment = source
+        .getStatements()
+        .find((s) => Node.isExportAssignment(s));
+    if (exportAssignment && Node.isExportAssignment(exportAssignment)) {
+        const expr = exportAssignment.getExpression();
+        if (Node.isIdentifier(expr)) {
+            const symbol = expr.getSymbol();
+            if (symbol) {
+                const decl = symbol.getDeclarations()[0];
+                if (decl && Node.isVariableDeclaration(decl)) {
+                    const init = decl.getInitializer();
+                    if (init && Node.isArrowFunction(init))
+                        return init;
+                    if (init && Node.isFunctionExpression(init))
+                        return init;
+                }
+            }
+        }
+        if (Node.isArrowFunction(expr))
+            return expr;
+        if (Node.isFunctionExpression(expr))
+            return expr;
+    }
+    return null;
+}
+function isSoloInstallCeraphStatement(stmt) {
+    if (Node.isExpressionStatement(stmt)) {
+        const expr = stmt.getExpression();
+        if (Node.isCallExpression(expr)) {
+            const callee = expr.getExpression();
+            if (Node.isIdentifier(callee) && callee.getText() === INSTALL_CALL) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function classifyUseEffect(call) {
+    const args = call.getArguments();
+    if (args.length === 0)
+        return "unrelated";
+    const callback = args[0];
+    let body = null;
+    if (Node.isArrowFunction(callback) || Node.isFunctionExpression(callback)) {
+        const b = callback.getBody();
+        if (Node.isBlock(b))
+            body = b;
+        else {
+            if (Node.isCallExpression(b)) {
+                const callee = b.getExpression();
+                if (Node.isIdentifier(callee) && callee.getText() === INSTALL_CALL) {
+                    return "installCeraph-only";
+                }
+            }
+            return "unrelated";
+        }
+    }
+    else {
+        return "unrelated";
+    }
+    if (!body)
+        return "unrelated";
+    const statements = body.getStatements();
+    if (statements.length === 0)
+        return "unrelated";
+    let hasInstallCeraph = false;
+    let hasOthers = false;
+    for (const s of statements) {
+        if (isSoloInstallCeraphStatement(s)) {
+            hasInstallCeraph = true;
+        }
+        else {
+            hasOthers = true;
+        }
+    }
+    if (!hasInstallCeraph)
+        return "unrelated";
+    return hasOthers ? "installCeraph-with-others" : "installCeraph-only";
+}
+function listUseEffectsInBody(fn) {
+    const block = fn.getBody();
+    if (!block || !Node.isBlock(block))
+        return [];
+    const out = [];
+    block.forEachDescendant((node) => {
+        if (Node.isCallExpression(node)) {
+            const callee = node.getExpression();
+            if (Node.isIdentifier(callee) && callee.getText() === "useEffect") {
+                out.push(node);
+            }
+        }
+    });
+    return out;
+}
+function dropUseEffectImportIfOrphan(source) {
+    const decl = source.getImportDeclaration("react");
+    if (!decl)
+        return false;
+    const named = decl.getNamedImports();
+    const target = named.find((n) => n.getName() === "useEffect");
+    if (!target)
+        return false;
+    const aliasNode = target.getAliasNode();
+    if (aliasNode)
+        return false;
+    let stillReferenced = false;
+    source.forEachDescendant((node) => {
+        if (stillReferenced)
+            return;
+        if (Node.isIdentifier(node) && node.getText() === "useEffect") {
+            const parent = node.getParent();
+            if (parent && (Node.isImportSpecifier(parent) || Node.isImportClause(parent))) {
+                return;
+            }
+            stillReferenced = true;
+        }
+    });
+    if (stillReferenced)
+        return false;
+    target.remove();
+    const remaining = decl.getNamedImports();
+    const hasDefault = decl.getDefaultImport() != null;
+    const hasNamespace = decl.getNamespaceImport() != null;
+    if (remaining.length === 0 && !hasDefault && !hasNamespace) {
+        decl.remove();
+    }
+    return true;
+}
+function removeInstallCeraphImport(source) {
+    const decl = source.getImportDeclaration(SHIM_MODULE);
+    if (!decl)
+        return false;
+    const named = decl.getNamedImports();
+    const target = named.find((n) => n.getName() === INSTALL_CALL);
+    if (!target)
+        return false;
+    target.remove();
+    const remaining = decl.getNamedImports();
+    const hasDefault = decl.getDefaultImport() != null;
+    if (remaining.length === 0 && !hasDefault) {
+        decl.remove();
+    }
+    return true;
+}
+export async function revertBoot(projectDir) {
+    const target = await detectRevertTarget(projectDir);
+    if (!target) {
+        return { status: "no-layout-found" };
+    }
+    const project = new Project({
+        useInMemoryFileSystem: false,
+        skipAddingFilesFromTsConfig: true,
+        skipFileDependencyResolution: true,
+        skipLoadingLibFiles: true,
+        compilerOptions: { allowJs: true, jsx: 1 },
+        manipulationSettings: { indentationText: IndentationText.TwoSpaces },
+    });
+    const source = project.addSourceFileAtPath(target.filePath);
+    const fn = findDefaultExportFunction(source);
+    if (!fn) {
+        const removedImport = removeInstallCeraphImport(source);
+        if (removedImport) {
+            await writeFile(target.filePath, source.getFullText(), "utf-8");
+            return {
+                status: "reverted",
+                target,
+                removedUseEffect: false,
+                removedImport: true,
+            };
+        }
+        return { status: "already-reverted", target };
+    }
+    const useEffects = listUseEffectsInBody(fn);
+    const candidates = useEffects.map((u) => ({ call: u, kind: classifyUseEffect(u) }));
+    const soloCandidates = candidates.filter((c) => c.kind === "installCeraph-only");
+    const mixedCandidates = candidates.filter((c) => c.kind === "installCeraph-with-others");
+    if (mixedCandidates.length > 0) {
+        return {
+            status: "skipped",
+            target,
+            reason: "useEffect contains other statements",
+        };
+    }
+    let removedUseEffect = false;
+    for (const c of soloCandidates) {
+        const stmt = c.call.getFirstAncestorByKind(SyntaxKind.ExpressionStatement);
+        if (stmt) {
+            stmt.remove();
+            removedUseEffect = true;
+        }
+    }
+    const removedImport = removeInstallCeraphImport(source);
+    if (removedUseEffect) {
+        dropUseEffectImportIfOrphan(source);
+    }
+    if (!removedUseEffect && !removedImport) {
+        return { status: "already-reverted", target };
+    }
+    await writeFile(target.filePath, source.getFullText(), "utf-8");
+    return {
+        status: "reverted",
+        target,
+        removedUseEffect,
+        removedImport,
+    };
+}

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

@@ -0,0 +1,12 @@
+export interface CameraFileRevertResult {
+    path: string;
+    relPath: string;
+    ceraphCamerasRemoved: number;
+    importDropped: boolean;
+    importRestored: boolean;
+}
+export interface RevertCameraResult {
+    files: CameraFileRevertResult[];
+    filesScanned: number;
+}
+export declare function revertCamera(projectDir: string): Promise<RevertCameraResult>;