@ceraph/react-native-mcp 0.2.1 → 0.3.1

package/dist/uninstall/walkthrough.js

@@ -0,0 +1,1244 @@
+import { copyFile, mkdir, readFile, rm, stat } from "node:fs/promises";
+import { tmpdir, homedir } from "node:os";
+import { dirname, isAbsolute, join, relative } from "node:path";
+import { Node, Project, } from "ts-morph";
+import { detectMonorepoSubpackages, } from "../init/monorepo.js";
+import { snapshotFile, restoreFile } from "../init/ast-camera.js";
+import { revertGitignore, } from "./revert-gitignore.js";
+import { revertSignalHostEnv, } from "./revert-signal-host-env.js";
+import { revertCeraphDir, } from "./revert-ceraph-dir.js";
+import { revertAuth } from "./revert-auth.js";
+import { revertCeraphUrlScheme, } from "./revert-scheme.js";
+import { revertMcpClients, revertUserGlobalMcpClients, USER_GLOBAL_MCP_CLIENTS, userGlobalMcpClientPaths, } from "./revert-mcp-clients.js";
+import { revertClaudeHooks, } from "./revert-claude-hooks.js";
+import { revertBoot, detectRevertTarget, } from "./revert-boot.js";
+import { revertCamera, } from "./revert-camera.js";
+import { revertPackage, } from "./revert-package.js";
+const NOOP_SPAWN = async (_) => ({ exitCode: 0 });
+export async function runUninstallWalkthrough(opts) {
+    const steps = [];
+    const emit = (step) => {
+        steps.push(step);
+        opts.onStep?.(step);
+    };
+    const monorepo = await resolveWorkingDir(opts);
+    if (monorepo.kind === "error") {
+        const step = {
+            name: "monorepo",
+            status: "error",
+            details: { matches: monorepo.matches },
+            remediation: monorepo.remediation,
+        };
+        emit(step);
+        return finalize(opts.projectDir, steps);
+    }
+    const workingDir = monorepo.workingDir;
+    const dryRun = opts.dryRun === true;
+    const cameraStep = await runCameraStep(workingDir, opts, dryRun);
+    emit(cameraStep);
+    const bootStep = await runBootStep(workingDir, opts, dryRun);
+    emit(bootStep);
+    const schemeStep = await runSchemeStep(workingDir, opts, dryRun);
+    emit(schemeStep);
+    const mcpStep = await runMcpClientsStep(workingDir, opts, dryRun);
+    emit(mcpStep);
+    const claudeHooksStep = await runClaudeHooksStep(workingDir, opts, dryRun);
+    emit(claudeHooksStep);
+    const gitignoreStep = await runGitignoreStep(workingDir, opts, dryRun);
+    emit(gitignoreStep);
+    const signalHostStep = await runSignalHostStep(opts, dryRun);
+    emit(signalHostStep);
+    const ceraphDirStep = await runCeraphDirStep(workingDir, opts, dryRun);
+    emit(ceraphDirStep);
+    const authStep = await runAuthStep(opts, dryRun);
+    emit(authStep);
+    const packageStep = await runPackageStep(workingDir, opts, dryRun);
+    emit(packageStep);
+    return finalize(workingDir, steps);
+}
+async function resolveWorkingDir(opts) {
+    const detect = opts.detectMonorepo ?? detectMonorepoSubpackages;
+    const detection = await detect(opts.projectDir);
+    if (detection.kind === "none") {
+        return { kind: "ok", workingDir: opts.projectDir };
+    }
+    if (detection.kind === "single") {
+        const m = detection.matches[0];
+        if (!m)
+            return { kind: "ok", workingDir: opts.projectDir };
+        return { kind: "ok", workingDir: m.absPath };
+    }
+    return {
+        kind: "error",
+        matches: detection.matches.map((m) => ({
+            relPath: m.relPath,
+            absPath: m.absPath,
+        })),
+        remediation: "Multiple React Native subpackages detected. Pass --project-dir " +
+            "to target a specific subpackage, e.g. `--project-dir " +
+            `${detection.matches[0]?.relPath ?? "apps/mobile"}\`.`,
+    };
+}
+async function runCameraStep(workingDir, opts, dryRun) {
+    const primitive = opts.revertCamera ?? revertCamera;
+    if (dryRun) {
+        try {
+            const preview = await previewCameraRevert(workingDir, primitive);
+            return makeCameraStepFromResult(preview, { dryRun: true });
+        }
+        catch (err) {
+            return {
+                name: "camera",
+                status: "error",
+                details: { error: errMsg(err) },
+                remediation: "Dry-run camera preview failed. Re-run without --dry-run after " +
+                    "fixing the error above, or pass --project-dir if the path is wrong.",
+            };
+        }
+    }
+    const snapshots = new Map();
+    try {
+        const filesToSnapshot = await listFilesContainingCeraphCamera(workingDir);
+        for (const f of filesToSnapshot) {
+            snapshots.set(f, await snapshotFile(f));
+        }
+        const result = await primitive(workingDir);
+        return makeCameraStepFromResult(result, { dryRun: false });
+    }
+    catch (err) {
+        const restoreFailures = [];
+        for (const [path, snap] of snapshots) {
+            if (snap == null)
+                continue;
+            try {
+                await restoreFile(path, snap);
+            }
+            catch (restoreErr) {
+                restoreFailures.push(`${path}: ${errMsg(restoreErr)}`);
+            }
+        }
+        const baseRemediation = `Camera revert failed: ${errMsg(err)}.`;
+        const remediation = restoreFailures.length === 0
+            ? `${baseRemediation} All edited files were restored from snapshots.`
+            : `${baseRemediation} Some files could not be restored: ` +
+                restoreFailures.join("; ");
+        return {
+            name: "camera",
+            status: "error",
+            details: {
+                error: errMsg(err),
+                snapshotCount: snapshots.size,
+                restoreFailures,
+            },
+            remediation,
+        };
+    }
+}
+function makeCameraStepFromResult(result, ctx) {
+    const totalReverted = result.files.reduce((n, f) => n + f.ceraphCamerasRemoved, 0);
+    const imageKeysStripped = totalReverted;
+    if (result.files.length === 0) {
+        return {
+            name: "camera",
+            status: "already-reverted",
+            details: {
+                filesScanned: result.filesScanned,
+                ...(ctx.dryRun ? { dryRun: true } : {}),
+            },
+        };
+    }
+    const status = imageKeysStripped > 0 ? "warning" : "reverted";
+    const step = {
+        name: "camera",
+        status,
+        details: {
+            filesScanned: result.filesScanned,
+            filesEdited: result.files.map((f) => f.relPath),
+            ceraphCamerasRemoved: totalReverted,
+            importDropped: result.files.filter((f) => f.importDropped).length,
+            importRestored: result.files.filter((f) => f.importRestored).length,
+            imageKeysStripped,
+            ...(ctx.dryRun ? { dryRun: true } : {}),
+        },
+    };
+    if (status === "warning") {
+        step.remediation =
+            `revert-camera removed imageKey props from ${imageKeysStripped} ` +
+                `<CeraphCamera> tag(s). If any of those keys were customer-set ` +
+                `(not Ceraph-generated), re-apply them after install rebuilds the ` +
+                `camera surface.`;
+    }
+    return step;
+}
+async function listFilesContainingCeraphCamera(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",
+    ]);
+    const candidates = [];
+    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;
+            candidates.push(join(dir, entry.name));
+        }
+    };
+    for (const root of SCAN_ROOTS) {
+        await walk(join(projectDir, root));
+    }
+    for (const single of ["App.tsx", "App.jsx"]) {
+        candidates.push(join(projectDir, single));
+    }
+    const out = [];
+    for (const path of candidates) {
+        let raw;
+        try {
+            raw = await readFile(path, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        if (raw.includes("<CeraphCamera"))
+            out.push(path);
+    }
+    return out;
+}
+async function previewCameraRevert(projectDir, primitive) {
+    const files = await listFilesContainingCeraphCamera(projectDir);
+    const tmp = join(tmpdir(), `ceraph-uninstall-preview-${Date.now()}-${Math.random()
+        .toString(36)
+        .slice(2)}`);
+    try {
+        await mkdir(tmp, { recursive: true });
+        for (const abs of files) {
+            const rel = relative(projectDir, abs);
+            const dest = join(tmp, rel);
+            await mkdir(dirname(dest), { recursive: true });
+            await copyFile(abs, dest);
+        }
+        return await primitive(tmp);
+    }
+    finally {
+        try {
+            await rm(tmp, { recursive: true, force: true });
+        }
+        catch {
+        }
+    }
+}
+async function runBootStep(workingDir, opts, dryRun) {
+    const primitive = opts.revertBoot ?? revertBoot;
+    const detect = opts.detectBootTarget ?? detectRevertTarget;
+    if (dryRun) {
+        try {
+            const target = await detect(workingDir);
+            if (!target) {
+                return {
+                    name: "boot",
+                    status: "already-reverted",
+                    details: { reason: "no layout file detected", dryRun: true },
+                };
+            }
+            const tmpProj = await stageSingleFileInTmp(target.filePath, workingDir);
+            try {
+                const result = await primitive(tmpProj.projectDir);
+                return await boot_resultToStep(result, workingDir, target, opts, true);
+            }
+            finally {
+                await rm(tmpProj.tmpRoot, { recursive: true, force: true }).catch(() => undefined);
+            }
+        }
+        catch (err) {
+            return {
+                name: "boot",
+                status: "error",
+                details: { error: errMsg(err), dryRun: true },
+                remediation: "Dry-run boot preview failed; re-run without --dry-run to see " +
+                    "the real error path.",
+            };
+        }
+    }
+    try {
+        const result = await primitive(workingDir);
+        const target = result.status === "no-layout-found"
+            ? null
+            : result.target;
+        return await boot_resultToStep(result, workingDir, target, opts, false);
+    }
+    catch (err) {
+        return {
+            name: "boot",
+            status: "error",
+            details: { error: errMsg(err) },
+            remediation: "Boot revert raised. Check the layout file for syntax errors " +
+                "before re-running.",
+        };
+    }
+}
+async function boot_resultToStep(result, workingDir, target, opts, dryRun) {
+    switch (result.status) {
+        case "reverted":
+            return {
+                name: "boot",
+                status: "reverted",
+                details: {
+                    target: result.target,
+                    removedUseEffect: result.removedUseEffect,
+                    removedImport: result.removedImport,
+                    ...(dryRun ? { dryRun: true } : {}),
+                },
+            };
+        case "already-reverted":
+            return {
+                name: "boot",
+                status: "already-reverted",
+                details: { target: result.target, ...(dryRun ? { dryRun: true } : {}) },
+            };
+        case "no-layout-found":
+            return {
+                name: "boot",
+                status: "already-reverted",
+                details: { reason: "no layout file detected", ...(dryRun ? { dryRun: true } : {}) },
+            };
+        case "skipped": {
+            const remediationDetail = await analyzeBootSkippedConflict(result.target.filePath);
+            return {
+                name: "boot",
+                status: "manual",
+                details: {
+                    target: result.target,
+                    reason: result.reason,
+                    location: remediationDetail.location,
+                    otherStatements: remediationDetail.otherStatements,
+                    ...(remediationDetail.parseError !== undefined
+                        ? { parseError: remediationDetail.parseError }
+                        : {}),
+                    ...(dryRun ? { dryRun: true } : {}),
+                },
+                remediation: `installCeraph() is wrapped in a useEffect that also contains ` +
+                    `other statements (see ${result.target.filePath}` +
+                    (remediationDetail.location
+                        ? `:${remediationDetail.location.line}`
+                        : "") +
+                    `). Remove the \`installCeraph()\` call by hand without ` +
+                    `dropping your own code, then re-run \`npx @ceraph/react-native-mcp ` +
+                    `uninstall\`.` +
+                    (remediationDetail.parseError !== undefined
+                        ? ` (Note: re-parse failed — line info missing: ${remediationDetail.parseError})`
+                        : ""),
+            };
+        }
+    }
+    return {
+        name: "boot",
+        status: "error",
+        details: { result },
+        remediation: "Boot revert returned an unrecognised status shape.",
+    };
+}
+async function analyzeBootSkippedConflict(filePath) {
+    try {
+        const project = new Project({
+            useInMemoryFileSystem: false,
+            skipAddingFilesFromTsConfig: true,
+            skipFileDependencyResolution: true,
+            skipLoadingLibFiles: true,
+            compilerOptions: { allowJs: true, jsx: 1 },
+        });
+        const source = project.addSourceFileAtPath(filePath);
+        const fn = findDefaultExportFn(source);
+        if (!fn)
+            return { location: null, otherStatements: [] };
+        const body = fn.getBody();
+        if (!body || !Node.isBlock(body)) {
+            return { location: null, otherStatements: [] };
+        }
+        let location = null;
+        let otherStatements = [];
+        body.forEachDescendant((node) => {
+            if (location)
+                return;
+            if (!Node.isCallExpression(node))
+                return;
+            const callee = node.getExpression();
+            if (!Node.isIdentifier(callee) || callee.getText() !== "useEffect") {
+                return;
+            }
+            const args = node.getArguments();
+            const cb = args[0];
+            if (!cb)
+                return;
+            if (!Node.isArrowFunction(cb) && !Node.isFunctionExpression(cb)) {
+                return;
+            }
+            const cbBody = cb.getBody();
+            if (!Node.isBlock(cbBody))
+                return;
+            const stmts = cbBody.getStatements();
+            const installCeraphStmts = [];
+            const others = [];
+            for (const s of stmts) {
+                if (isSoloInstallCeraphCall(s))
+                    installCeraphStmts.push(s);
+                else
+                    others.push(s);
+            }
+            if (installCeraphStmts.length > 0 && others.length > 0) {
+                location = { line: node.getStartLineNumber() };
+                otherStatements = others.map((s) => s.getText());
+            }
+        });
+        return { location, otherStatements };
+    }
+    catch (err) {
+        return {
+            location: null,
+            otherStatements: [],
+            parseError: errMsg(err),
+        };
+    }
+}
+function findDefaultExportFn(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 isSoloInstallCeraphCall(stmt) {
+    if (!Node.isExpressionStatement(stmt))
+        return false;
+    const expr = stmt.getExpression();
+    if (!Node.isCallExpression(expr))
+        return false;
+    const callee = expr.getExpression();
+    return Node.isIdentifier(callee) && callee.getText() === "installCeraph";
+}
+async function runSchemeStep(workingDir, opts, dryRun) {
+    const primitive = opts.revertCeraphUrlScheme ?? revertCeraphUrlScheme;
+    if (dryRun) {
+        try {
+            const tmpProj = await stageProjectFilesForSchemeDryRun(workingDir);
+            try {
+                const result = await primitive(tmpProj.projectDir);
+                return schemeResultToStep(result, true);
+            }
+            finally {
+                await rm(tmpProj.tmpRoot, { recursive: true, force: true }).catch(() => undefined);
+            }
+        }
+        catch (err) {
+            return {
+                name: "scheme",
+                status: "error",
+                details: { error: errMsg(err), dryRun: true },
+            };
+        }
+    }
+    try {
+        const result = await primitive(workingDir);
+        return schemeResultToStep(result, false);
+    }
+    catch (err) {
+        return {
+            name: "scheme",
+            status: "error",
+            details: { error: errMsg(err) },
+        };
+    }
+}
+function schemeResultToStep(result, dryRun) {
+    const dryRunTag = dryRun ? { dryRun: true } : {};
+    switch (result.status) {
+        case "reverted":
+            return {
+                name: "scheme",
+                status: "reverted",
+                details: {
+                    path: result.path,
+                    previousScheme: result.previousScheme,
+                    nextScheme: result.nextScheme,
+                    ...dryRunTag,
+                },
+            };
+        case "already-reverted":
+            return {
+                name: "scheme",
+                status: "already-reverted",
+                details: { path: result.path, ...dryRunTag },
+            };
+        case "manual":
+            return {
+                name: "scheme",
+                status: "manual",
+                details: { kind: result.kind, path: result.path, ...dryRunTag },
+                remediation: result.remediation,
+            };
+        case "no-rn-project":
+            return {
+                name: "scheme",
+                status: "already-reverted",
+                details: { reason: "no RN project detected", ...dryRunTag },
+            };
+    }
+}
+async function stageProjectFilesForSchemeDryRun(projectDir) {
+    const tmpRoot = join(tmpdir(), `ceraph-uninstall-scheme-preview-${Date.now()}-${Math.random()
+        .toString(36)
+        .slice(2)}`);
+    return stageOrCleanup(tmpRoot, async () => {
+        await mkdir(tmpRoot, { recursive: true });
+        for (const name of ["app.json", "app.config.js", "app.config.ts"]) {
+            const src = join(projectDir, name);
+            try {
+                await copyFile(src, join(tmpRoot, name));
+            }
+            catch {
+            }
+        }
+        for (const native of ["ios", "android"]) {
+            try {
+                await stat(join(projectDir, native));
+                await mkdir(join(tmpRoot, native), { recursive: true });
+            }
+            catch {
+            }
+        }
+        return { projectDir: tmpRoot, tmpRoot };
+    });
+}
+async function runMcpClientsStep(workingDir, opts, dryRun) {
+    const primitive = opts.revertMcpClients ?? revertMcpClients;
+    const globalPrimitive = opts.revertUserGlobalMcpClients ?? revertUserGlobalMcpClients;
+    const home = opts.homeDir?.();
+    if (dryRun) {
+        let tmpProj = null;
+        let tmpHome = null;
+        try {
+            tmpProj = await stageMcpClientFiles(workingDir);
+            tmpHome = await stageUserGlobalMcpClientFiles(home);
+            const result = await primitive(tmpProj.projectDir);
+            const globalResult = await globalPrimitive({ home: tmpHome.tmpHome });
+            return mcpResultToStep(result, globalResult, true);
+        }
+        catch (err) {
+            return {
+                name: "mcp-clients",
+                status: "error",
+                details: { error: errMsg(err), dryRun: true },
+            };
+        }
+        finally {
+            if (tmpProj) {
+                await rm(tmpProj.tmpRoot, { recursive: true, force: true }).catch(() => undefined);
+            }
+            if (tmpHome) {
+                await rm(tmpHome.tmpRoot, { recursive: true, force: true }).catch(() => undefined);
+            }
+        }
+    }
+    try {
+        const result = await primitive(workingDir);
+        const globalResult = await globalPrimitive({ home });
+        return mcpResultToStep(result, globalResult, false);
+    }
+    catch (err) {
+        return {
+            name: "mcp-clients",
+            status: "error",
+            details: { error: errMsg(err) },
+        };
+    }
+}
+function mcpResultToStep(result, globalResult, dryRun) {
+    const combined = [...result.files, ...globalResult.files];
+    const touched = combined.filter((f) => f.status === "removed-entries" || f.status === "deleted-file");
+    const dryRunTag = dryRun ? { dryRun: true } : {};
+    if (touched.length === 0) {
+        return {
+            name: "mcp-clients",
+            status: "already-reverted",
+            details: {
+                files: result.files,
+                userGlobalFiles: globalResult.files,
+                ...dryRunTag,
+            },
+        };
+    }
+    return {
+        name: "mcp-clients",
+        status: "reverted",
+        details: {
+            files: result.files,
+            userGlobalFiles: globalResult.files,
+            touched: touched.length,
+            ...dryRunTag,
+        },
+    };
+}
+async function stageMcpClientFiles(projectDir) {
+    const tmpRoot = join(tmpdir(), `ceraph-uninstall-mcp-preview-${Date.now()}-${Math.random()
+        .toString(36)
+        .slice(2)}`);
+    return stageOrCleanup(tmpRoot, async () => {
+        await mkdir(tmpRoot, { recursive: true });
+        const targets = [
+            ".mcp.json",
+            join(".cursor", "mcp.json"),
+            join(".vscode", "mcp.json"),
+            join(".codex", "config.toml"),
+        ];
+        for (const rel of targets) {
+            const src = join(projectDir, rel);
+            const dest = join(tmpRoot, rel);
+            try {
+                await mkdir(dirname(dest), { recursive: true });
+                await copyFile(src, dest);
+            }
+            catch {
+            }
+        }
+        return { projectDir: tmpRoot, tmpRoot };
+    });
+}
+async function stageUserGlobalMcpClientFiles(home) {
+    const tmpRoot = join(tmpdir(), `ceraph-uninstall-mcp-global-preview-${Date.now()}-${Math.random()
+        .toString(36)
+        .slice(2)}`);
+    return stageOrCleanup(tmpRoot, async () => {
+        const tmpHome = join(tmpRoot, "home");
+        await mkdir(tmpHome, { recursive: true });
+        const realPaths = userGlobalMcpClientPaths(home);
+        for (let i = 0; i < USER_GLOBAL_MCP_CLIENTS.length; i++) {
+            const client = USER_GLOBAL_MCP_CLIENTS[i];
+            const realEntry = realPaths[i];
+            if (!client || !realEntry)
+                continue;
+            const dest = join(tmpHome, ...client.file);
+            try {
+                await mkdir(dirname(dest), { recursive: true });
+                await copyFile(realEntry.path, dest);
+            }
+            catch {
+            }
+        }
+        return { tmpHome, tmpRoot };
+    });
+}
+async function runClaudeHooksStep(workingDir, opts, dryRun) {
+    const primitive = opts.revertClaudeHooks ?? revertClaudeHooks;
+    if (dryRun) {
+        try {
+            const tmpProj = await stageClaudeHookFiles(workingDir);
+            try {
+                const result = await primitive({ projectDir: tmpProj.projectDir });
+                return claudeHooksResultToStep(result, true);
+            }
+            finally {
+                await rm(tmpProj.tmpRoot, { recursive: true, force: true }).catch(() => undefined);
+            }
+        }
+        catch (err) {
+            return {
+                name: "claude-hooks",
+                status: "error",
+                details: { error: errMsg(err), dryRun: true },
+            };
+        }
+    }
+    try {
+        const result = await primitive({ projectDir: workingDir });
+        return claudeHooksResultToStep(result, false);
+    }
+    catch (err) {
+        return {
+            name: "claude-hooks",
+            status: "error",
+            details: { error: errMsg(err) },
+        };
+    }
+}
+function claudeHooksResultToStep(result, dryRun) {
+    const dryRunTag = dryRun ? { dryRun: true } : {};
+    switch (result.status) {
+        case "reverted":
+            return {
+                name: "claude-hooks",
+                status: "reverted",
+                details: { ...result.details, ...dryRunTag },
+            };
+        case "already-reverted":
+            return {
+                name: "claude-hooks",
+                status: "already-reverted",
+                details: { ...result.details, ...dryRunTag },
+            };
+        case "manual":
+            return {
+                name: "claude-hooks",
+                status: "manual",
+                details: { ...result.details, ...dryRunTag },
+                remediation: `Hook script(s) were customized after init wrote them, so the ` +
+                    `reverter left them in place: ${result.details.scriptsLeftAlone.join(", ")}. ` +
+                    `If you no longer need the customized version, delete the file ` +
+                    `manually. Settings entries pointing at the script(s) ` +
+                    (result.details.settingsFilesModified.length > 0
+                        ? `were removed from ${result.details.settingsFilesModified.join(", ")}.`
+                        : `were not touched in this run.`),
+            };
+        case "skipped":
+            return {
+                name: "claude-hooks",
+                status: "skipped",
+                details: { ...result.details, ...dryRunTag },
+            };
+    }
+}
+async function stageClaudeHookFiles(projectDir) {
+    const tmpRoot = join(tmpdir(), `ceraph-uninstall-claude-hooks-preview-${Date.now()}-${Math.random()
+        .toString(36)
+        .slice(2)}`);
+    return stageOrCleanup(tmpRoot, async () => {
+        await mkdir(tmpRoot, { recursive: true });
+        const targets = [
+            join(".claude", "hooks", "rn-error-notify.sh"),
+            join(".claude", "hooks", "rn-flow-progress-notify.sh"),
+            join(".claude", "settings.json"),
+            join(".claude", "settings.local.json"),
+        ];
+        for (const rel of targets) {
+            const src = join(projectDir, rel);
+            const dest = join(tmpRoot, rel);
+            try {
+                await mkdir(dirname(dest), { recursive: true });
+                await copyFile(src, dest);
+            }
+            catch {
+            }
+        }
+        return { projectDir: tmpRoot, tmpRoot };
+    });
+}
+async function runGitignoreStep(workingDir, opts, dryRun) {
+    const primitive = opts.revertGitignore ?? revertGitignore;
+    if (dryRun) {
+        const tmpRoot = join(tmpdir(), `ceraph-uninstall-gitignore-preview-${Date.now()}-${Math.random()
+            .toString(36)
+            .slice(2)}`);
+        try {
+            try {
+                await mkdir(tmpRoot, { recursive: true });
+                try {
+                    await copyFile(join(workingDir, ".gitignore"), join(tmpRoot, ".gitignore"));
+                }
+                catch {
+                }
+                const result = await primitive(tmpRoot);
+                return gitignoreResultToStep(result, true);
+            }
+            finally {
+                await rm(tmpRoot, { recursive: true, force: true }).catch(() => undefined);
+            }
+        }
+        catch (err) {
+            return {
+                name: "gitignore",
+                status: "error",
+                details: { error: errMsg(err), dryRun: true },
+            };
+        }
+    }
+    try {
+        const result = await primitive(workingDir);
+        return gitignoreResultToStep(result, false);
+    }
+    catch (err) {
+        return {
+            name: "gitignore",
+            status: "error",
+            details: { error: errMsg(err) },
+        };
+    }
+}
+function gitignoreResultToStep(result, dryRun) {
+    const dryRunTag = dryRun ? { dryRun: true } : {};
+    switch (result.status) {
+        case "reverted":
+            return {
+                name: "gitignore",
+                status: "reverted",
+                details: {
+                    path: result.path,
+                    removedLines: result.removedLines,
+                    ...dryRunTag,
+                },
+            };
+        case "already-reverted":
+            return {
+                name: "gitignore",
+                status: "already-reverted",
+                details: { path: result.path, ...dryRunTag },
+            };
+        case "no-gitignore":
+            return {
+                name: "gitignore",
+                status: "already-reverted",
+                details: { reason: "no .gitignore", ...dryRunTag },
+            };
+    }
+}
+async function runSignalHostStep(opts, dryRun) {
+    const primitive = opts.revertSignalHostEnv ?? revertSignalHostEnv;
+    const home = opts.homeDir?.();
+    if (dryRun) {
+        try {
+            const fakeHome = await mirrorShellProfile(home);
+            try {
+                const result = await primitive({ home: fakeHome.tmpHome });
+                return signalHostResultToStep(result, true);
+            }
+            finally {
+                await rm(fakeHome.tmpRoot, { recursive: true, force: true }).catch(() => undefined);
+            }
+        }
+        catch (err) {
+            return {
+                name: "signal-host",
+                status: "error",
+                details: { error: errMsg(err), dryRun: true },
+            };
+        }
+    }
+    try {
+        const result = await primitive({ home });
+        return signalHostResultToStep(result, false);
+    }
+    catch (err) {
+        return {
+            name: "signal-host",
+            status: "error",
+            details: { error: errMsg(err) },
+        };
+    }
+}
+function signalHostResultToStep(result, dryRun) {
+    const dryRunTag = dryRun ? { dryRun: true } : {};
+    switch (result.status) {
+        case "reverted":
+            return {
+                name: "signal-host",
+                status: "reverted",
+                details: {
+                    path: result.path,
+                    shell: result.shell,
+                    removedIp: result.removedIp,
+                    ...dryRunTag,
+                },
+            };
+        case "already-reverted":
+            return {
+                name: "signal-host",
+                status: "already-reverted",
+                details: { path: result.path, shell: result.shell, ...dryRunTag },
+            };
+        case "no-profile":
+            return {
+                name: "signal-host",
+                status: "already-reverted",
+                details: { reason: "no shell profile", path: result.path, ...dryRunTag },
+            };
+    }
+}
+async function mirrorShellProfile(home) {
+    const realHome = home ?? homedir();
+    const tmpRoot = join(tmpdir(), `ceraph-uninstall-shell-preview-${Date.now()}-${Math.random()
+        .toString(36)
+        .slice(2)}`);
+    return stageOrCleanup(tmpRoot, async () => {
+        const tmpHome = join(tmpRoot, "home");
+        await mkdir(tmpHome, { recursive: true });
+        for (const rc of [".zshrc", ".bashrc"]) {
+            try {
+                await copyFile(join(realHome, rc), join(tmpHome, rc));
+            }
+            catch {
+            }
+        }
+        return { tmpHome, tmpRoot };
+    });
+}
+async function runCeraphDirStep(workingDir, opts, dryRun) {
+    const primitive = opts.revertCeraphDir ?? revertCeraphDir;
+    if (!opts.purgeImages) {
+        try {
+            const preview = await primitive({
+                projectDir: workingDir,
+                confirm: false,
+            });
+            if (preview.status === "already-reverted") {
+                return {
+                    name: "ceraph-dir",
+                    status: "already-reverted",
+                    details: { path: preview.path, ...(dryRun ? { dryRun: true } : {}) },
+                };
+            }
+            if (preview.status === "skipped-needs-confirmation") {
+                return {
+                    name: "ceraph-dir",
+                    status: "skipped",
+                    details: {
+                        path: preview.path,
+                        paths: preview.paths,
+                        ...(dryRun ? { dryRun: true } : {}),
+                    },
+                    remediation: "Re-run with --purge-images to delete .ceraph/ (camera images, " +
+                        "design snapshots, run artifacts). Default leaves them in place " +
+                        "so a re-install picks up where you left off.",
+                };
+            }
+            return {
+                name: "ceraph-dir",
+                status: "error",
+                details: {
+                    unexpectedStatus: preview.status,
+                    ...(dryRun ? { dryRun: true } : {}),
+                },
+                remediation: "ceraph-dir preview returned an unexpected status; pass " +
+                    "--purge-images explicitly to delete .ceraph/.",
+            };
+        }
+        catch (err) {
+            return {
+                name: "ceraph-dir",
+                status: "error",
+                details: { error: errMsg(err), ...(dryRun ? { dryRun: true } : {}) },
+            };
+        }
+    }
+    if (dryRun) {
+        try {
+            const preview = await primitive({
+                projectDir: workingDir,
+                confirm: false,
+            });
+            if (preview.status === "already-reverted") {
+                return {
+                    name: "ceraph-dir",
+                    status: "already-reverted",
+                    details: { path: preview.path, dryRun: true },
+                };
+            }
+            if (preview.status === "skipped-needs-confirmation") {
+                return {
+                    name: "ceraph-dir",
+                    status: "reverted",
+                    details: {
+                        path: preview.path,
+                        paths: preview.paths,
+                        dryRun: true,
+                    },
+                };
+            }
+            return {
+                name: "ceraph-dir",
+                status: "error",
+                details: { unexpectedStatus: preview.status, dryRun: true },
+            };
+        }
+        catch (err) {
+            return {
+                name: "ceraph-dir",
+                status: "error",
+                details: { error: errMsg(err), dryRun: true },
+            };
+        }
+    }
+    try {
+        const result = await primitive({
+            projectDir: workingDir,
+            confirm: true,
+        });
+        switch (result.status) {
+            case "deleted":
+                return {
+                    name: "ceraph-dir",
+                    status: "reverted",
+                    details: {
+                        path: result.path,
+                        deletedEntries: result.deletedEntries,
+                    },
+                };
+            case "already-reverted":
+                return {
+                    name: "ceraph-dir",
+                    status: "already-reverted",
+                    details: { path: result.path },
+                };
+            case "skipped-needs-confirmation":
+                return {
+                    name: "ceraph-dir",
+                    status: "skipped",
+                    details: { path: result.path, unexpected: true },
+                };
+        }
+    }
+    catch (err) {
+        return {
+            name: "ceraph-dir",
+            status: "error",
+            details: { error: errMsg(err) },
+        };
+    }
+}
+async function runAuthStep(opts, dryRun) {
+    const primitive = opts.revertAuth ?? revertAuth;
+    const home = opts.homeDir?.();
+    if (!opts.global) {
+        try {
+            const result = await primitive({ global: false, home });
+            return {
+                name: "auth",
+                status: "skipped",
+                details: { path: result.path, ...(dryRun ? { dryRun: true } : {}) },
+                remediation: "Re-run with --global to delete ~/.ceraph/auth.json. " +
+                    "Note: this token is shared across every Ceraph install on " +
+                    "this machine — removing it logs you out everywhere.",
+            };
+        }
+        catch (err) {
+            return {
+                name: "auth",
+                status: "error",
+                details: { error: errMsg(err), ...(dryRun ? { dryRun: true } : {}) },
+            };
+        }
+    }
+    if (dryRun) {
+        try {
+            const realHome = home ?? homedir();
+            const path = join(realHome, ".ceraph", "auth.json");
+            let exists = false;
+            try {
+                await stat(path);
+                exists = true;
+            }
+            catch {
+                exists = false;
+            }
+            return {
+                name: "auth",
+                status: exists ? "reverted" : "already-reverted",
+                details: { path, dryRun: true, wouldDelete: exists },
+            };
+        }
+        catch (err) {
+            return {
+                name: "auth",
+                status: "error",
+                details: { error: errMsg(err), dryRun: true },
+            };
+        }
+    }
+    try {
+        const result = await primitive({ global: true, home });
+        switch (result.status) {
+            case "deleted":
+                return {
+                    name: "auth",
+                    status: "reverted",
+                    details: { path: result.path },
+                };
+            case "already-reverted":
+                return {
+                    name: "auth",
+                    status: "already-reverted",
+                    details: { path: result.path },
+                };
+            case "skipped":
+                return {
+                    name: "auth",
+                    status: "skipped",
+                    details: { path: result.path, unexpected: true },
+                };
+        }
+    }
+    catch (err) {
+        return {
+            name: "auth",
+            status: "error",
+            details: { error: errMsg(err) },
+        };
+    }
+}
+async function runPackageStep(workingDir, opts, dryRun) {
+    const primitive = opts.revertPackage ?? revertPackage;
+    const spawnRemove = opts.spawnRemove;
+    if (dryRun) {
+        try {
+            const result = await primitive(workingDir, {
+                spawnRemove: NOOP_SPAWN,
+            });
+            return packageResultToStep(result, true);
+        }
+        catch (err) {
+            return {
+                name: "package",
+                status: "error",
+                details: { error: errMsg(err), dryRun: true },
+            };
+        }
+    }
+    try {
+        const result = await primitive(workingDir, spawnRemove ? { spawnRemove } : {});
+        return packageResultToStep(result, false);
+    }
+    catch (err) {
+        return {
+            name: "package",
+            status: "error",
+            details: { error: errMsg(err) },
+        };
+    }
+}
+function packageResultToStep(result, dryRun) {
+    const dryRunTag = dryRun ? { dryRun: true } : {};
+    switch (result.status) {
+        case "removed":
+            return {
+                name: "package",
+                status: "reverted",
+                details: {
+                    packageManager: result.pm,
+                    removedPackages: result.removedPackages,
+                    command: result.command,
+                    ...dryRunTag,
+                },
+            };
+        case "nothing-to-remove":
+            return {
+                name: "package",
+                status: "already-reverted",
+                details: { packageManager: result.pm, ...dryRunTag },
+            };
+        case "command-failed":
+            return {
+                name: "package",
+                status: "error",
+                details: {
+                    packageManager: result.pm,
+                    command: result.command,
+                    exitCode: result.exitCode,
+                    ...dryRunTag,
+                },
+                remediation: `${result.pm} ${result.command?.args.join(" ") ?? ""} exited ` +
+                    `with code ${result.exitCode}. Fix the error above and re-run ` +
+                    `\`npx @ceraph/react-native-mcp uninstall\`.`,
+            };
+    }
+}
+function errMsg(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+async function stageOrCleanup(tmpRoot, fn) {
+    try {
+        return await fn();
+    }
+    catch (err) {
+        try {
+            await rm(tmpRoot, { recursive: true, force: true });
+        }
+        catch {
+        }
+        throw err;
+    }
+}
+async function stageSingleFileInTmp(absPath, projectDir) {
+    const tmpRoot = join(tmpdir(), `ceraph-uninstall-boot-preview-${Date.now()}-${Math.random()
+        .toString(36)
+        .slice(2)}`);
+    return stageOrCleanup(tmpRoot, async () => {
+        const rel = relative(projectDir, absPath);
+        const safeRel = isAbsolute(rel) ? "App.tsx" : rel;
+        const dest = join(tmpRoot, safeRel);
+        await mkdir(dirname(dest), { recursive: true });
+        await copyFile(absPath, dest);
+        return { projectDir: tmpRoot, tmpRoot };
+    });
+}
+function finalize(workingDir, steps) {
+    const warnings = [];
+    const manualSteps = [];
+    let reverted = 0;
+    let skipped = 0;
+    for (const step of steps) {
+        if (step.status === "reverted")
+            reverted++;
+        else if (step.status === "skipped" || step.status === "already-reverted") {
+            skipped++;
+        }
+        if (step.status === "warning" && step.remediation) {
+            warnings.push(step.remediation);
+        }
+        if (step.status === "manual" && step.remediation) {
+            manualSteps.push(step.remediation);
+        }
+    }
+    return {
+        workingDir,
+        steps,
+        summary: { reverted, skipped, warnings, manualSteps },
+    };
+}