@ceraph/react-native-mcp 0.2.2 → 0.3.1

package/dist/uninstall/revert-mcp-clients.js

@@ -0,0 +1,194 @@
+import { readFile, unlink, access } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { writeFileAtomic } from "../utils/atomic-write.js";
+export const JSON_CLIENT_PATHS = [
+    ".mcp.json",
+    join(".cursor", "mcp.json"),
+    join(".vscode", "mcp.json"),
+];
+export const TOML_CLIENT_PATHS = [join(".codex", "config.toml")];
+export const USER_GLOBAL_MCP_CLIENTS = [
+    {
+        label: "Windsurf",
+        dir: [".codeium", "windsurf"],
+        file: [".codeium", "windsurf", "mcp_config.json"],
+    },
+    {
+        label: "Antigravity",
+        dir: [".gemini", "antigravity"],
+        file: [".gemini", "antigravity", "mcp_config.json"],
+    },
+];
+export function userGlobalMcpClientPaths(home) {
+    const h = home ?? homedir();
+    return USER_GLOBAL_MCP_CLIENTS.map((c) => ({
+        label: c.label,
+        path: join(h, ...c.file),
+    }));
+}
+export const SERVER_KEYS = ["mobile-mcp", "react-native-mcp"];
+async function defaultExists(p) {
+    try {
+        await access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function revertMcpClients(projectDir, 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 files = [];
+    for (const rel of JSON_CLIENT_PATHS) {
+        const abs = join(projectDir, rel);
+        if (!(await exists(abs))) {
+            files.push({ path: abs, status: "not-found" });
+            continue;
+        }
+        files.push(await revertJsonClient(abs, { read, write, unlink: unlinkFn }));
+    }
+    for (const rel of TOML_CLIENT_PATHS) {
+        const abs = join(projectDir, rel);
+        if (!(await exists(abs))) {
+            files.push({ path: abs, status: "not-found" });
+            continue;
+        }
+        files.push(await revertTomlClient(abs, { read, write, unlink: unlinkFn }));
+    }
+    return { files };
+}
+async function revertJsonClient(abs, io) {
+    const raw = await io.read(abs);
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return { path: abs, status: "malformed" };
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return { path: abs, status: "malformed" };
+    }
+    const obj = parsed;
+    const servers = obj.mcpServers;
+    if (!servers || typeof servers !== "object" || Array.isArray(servers)) {
+        return { path: abs, status: "no-changes" };
+    }
+    const map = servers;
+    const removedKeys = [];
+    for (const key of SERVER_KEYS) {
+        if (key in map) {
+            delete map[key];
+            removedKeys.push(key);
+        }
+    }
+    if (removedKeys.length === 0) {
+        return { path: abs, status: "no-changes" };
+    }
+    const otherTopKeys = Object.keys(obj).filter((k) => k !== "mcpServers");
+    const mcpEmpty = Object.keys(map).length === 0;
+    if (mcpEmpty && otherTopKeys.length === 0) {
+        await io.unlink(abs);
+        return { path: abs, status: "deleted-file", removedKeys };
+    }
+    const indentMatch = raw.match(/\n(\s+)"/);
+    const indent = indentMatch?.[1] ?? "  ";
+    const hadTrailingNewline = raw.endsWith("\n");
+    const out = JSON.stringify(obj, null, indent);
+    await io.write(abs, hadTrailingNewline ? out + "\n" : out);
+    return { path: abs, status: "removed-entries", removedKeys };
+}
+function stripTomlSections(raw, sectionHeadings) {
+    const lines = raw.split(/\r?\n/);
+    const hadTrailingNewline = raw.endsWith("\n");
+    if (hadTrailingNewline && lines.length > 0 && lines[lines.length - 1] === "") {
+        lines.pop();
+    }
+    const out = [];
+    const removedKeys = [];
+    let inDropSection = false;
+    let justExitedDrop = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        const isHeading = trimmed.startsWith("[") && trimmed.endsWith("]");
+        if (isHeading) {
+            const heading = trimmed.slice(1, -1).trim();
+            const isDropHeading = sectionHeadings.has(heading);
+            if (isDropHeading) {
+                if (out.length > 0 && out[out.length - 1] === "") {
+                    out.pop();
+                }
+                const key = heading.startsWith("mcp_servers.")
+                    ? heading.slice("mcp_servers.".length)
+                    : heading;
+                removedKeys.push(key);
+                inDropSection = true;
+                justExitedDrop = false;
+                continue;
+            }
+            if ((inDropSection || justExitedDrop) && out.length > 0 && out[out.length - 1] !== "") {
+                out.push("");
+            }
+            inDropSection = false;
+            justExitedDrop = false;
+            out.push(line);
+            continue;
+        }
+        if (inDropSection) {
+            justExitedDrop = true;
+            continue;
+        }
+        if (justExitedDrop) {
+            if (trimmed === "")
+                continue;
+            if (out.length > 0 && out[out.length - 1] !== "") {
+                out.push("");
+            }
+            justExitedDrop = false;
+            out.push(line);
+            continue;
+        }
+        out.push(line);
+    }
+    while (out.length > 0 && out[out.length - 1] === "") {
+        out.pop();
+    }
+    const joined = out.join("\n");
+    const next = hadTrailingNewline && joined.length > 0 ? joined + "\n" : joined;
+    return { next, removedKeys };
+}
+async function revertTomlClient(abs, io) {
+    const raw = await io.read(abs);
+    const headings = new Set(SERVER_KEYS.map((k) => `mcp_servers.${k}`));
+    const { next, removedKeys } = stripTomlSections(raw, headings);
+    if (removedKeys.length === 0) {
+        return { path: abs, status: "no-changes" };
+    }
+    if (next.trim().length === 0) {
+        await io.unlink(abs);
+        return { path: abs, status: "deleted-file", removedKeys };
+    }
+    await io.write(abs, next);
+    return { path: abs, status: "removed-entries", removedKeys };
+}
+export { stripTomlSections };
+export async function revertUserGlobalMcpClients(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 files = [];
+    for (const { path } of userGlobalMcpClientPaths(deps.home)) {
+        if (!(await exists(path))) {
+            files.push({ path, status: "not-found" });
+            continue;
+        }
+        files.push(await revertJsonClient(path, { read, write, unlink: unlinkFn }));
+    }
+    return { files };
+}

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

@@ -0,0 +1,34 @@
+export type PackageManager = "pnpm" | "yarn" | "bun" | "npm";
+export declare const LOCKFILES: ReadonlyArray<{
+    file: string;
+    pm: PackageManager;
+}>;
+export declare const CERAPH_PKG = "@ceraph/react-native-mcp";
+export declare const APPIUM_PKG = "appium-webdriveragent";
+export declare function detectPackageManager(projectDir: string): Promise<PackageManager>;
+export declare function removeArgv(pm: PackageManager, pkgs: string[]): {
+    bin: string;
+    args: string[];
+};
+export declare function listInstalledPackages(projectDir: string, pkgs: string[]): Promise<string[]>;
+export type RevertPackageStatus = "removed" | "nothing-to-remove" | "command-failed";
+export interface RevertPackageResult {
+    status: RevertPackageStatus;
+    pm: PackageManager;
+    removedPackages: string[];
+    command?: {
+        bin: string;
+        args: string[];
+    };
+    exitCode?: number;
+}
+export interface RevertPackageDeps {
+    spawnRemove?: (input: {
+        bin: string;
+        args: string[];
+        cwd: string;
+    }) => Promise<{
+        exitCode: number;
+    }>;
+}
+export declare function revertPackage(projectDir: string, deps?: RevertPackageDeps): Promise<RevertPackageResult>;

package/dist/uninstall/revert-package.js

@@ -0,0 +1,98 @@
+import { spawn } from "node:child_process";
+import { readFile, access } from "node:fs/promises";
+import { join } from "node:path";
+export const LOCKFILES = [
+    { file: "pnpm-lock.yaml", pm: "pnpm" },
+    { file: "yarn.lock", pm: "yarn" },
+    { file: "bun.lockb", pm: "bun" },
+    { file: "bun.lock", pm: "bun" },
+    { file: "package-lock.json", pm: "npm" },
+];
+export const CERAPH_PKG = "@ceraph/react-native-mcp";
+export const APPIUM_PKG = "appium-webdriveragent";
+async function fileExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function detectPackageManager(projectDir) {
+    for (const { file, pm } of LOCKFILES) {
+        if (await fileExists(join(projectDir, file))) {
+            return pm;
+        }
+    }
+    return "npm";
+}
+export function removeArgv(pm, pkgs) {
+    switch (pm) {
+        case "pnpm":
+            return { bin: "pnpm", args: ["remove", ...pkgs] };
+        case "yarn":
+            return { bin: "yarn", args: ["remove", ...pkgs] };
+        case "bun":
+            return { bin: "bun", args: ["remove", ...pkgs] };
+        case "npm":
+            return { bin: "npm", args: ["uninstall", ...pkgs] };
+    }
+}
+export async function listInstalledPackages(projectDir, pkgs) {
+    let raw;
+    try {
+        raw = await readFile(join(projectDir, "package.json"), "utf-8");
+    }
+    catch {
+        return [];
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+    if (!parsed || typeof parsed !== "object")
+        return [];
+    const dep = parsed.dependencies ?? {};
+    const dev = parsed.devDependencies ?? {};
+    return pkgs.filter((p) => Boolean(dep[p] || dev[p]));
+}
+export async function revertPackage(projectDir, deps = {}) {
+    const pm = await detectPackageManager(projectDir);
+    const candidates = [CERAPH_PKG];
+    const listed = await listInstalledPackages(projectDir, candidates);
+    if (listed.length === 0) {
+        return { status: "nothing-to-remove", pm, removedPackages: [] };
+    }
+    const argv = removeArgv(pm, listed);
+    const runner = deps.spawnRemove ?? defaultSpawnRemove;
+    const result = await runner({ bin: argv.bin, args: argv.args, cwd: projectDir });
+    if (result.exitCode !== 0) {
+        return {
+            status: "command-failed",
+            pm,
+            removedPackages: [],
+            command: argv,
+            exitCode: result.exitCode,
+        };
+    }
+    return {
+        status: "removed",
+        pm,
+        removedPackages: listed,
+        command: argv,
+    };
+}
+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/revert-scheme.d.ts

@@ -0,0 +1,36 @@
+export declare const CERAPH_SCHEME = "ceraph";
+export type RevertSchemeResult = {
+    status: "reverted";
+    path: string;
+    previousScheme: string | string[];
+    nextScheme: string | string[] | undefined;
+} | {
+    status: "already-reverted";
+    path: string;
+} | {
+    status: "manual";
+    kind: "expo-dynamic" | "bare-rn";
+    path?: string;
+    remediation: string;
+} | {
+    status: "no-rn-project";
+};
+export interface RevertSchemeDeps {
+    readFile?: (p: string) => Promise<string>;
+    writeFile?: (p: string, c: string) => Promise<void>;
+    fileExists?: (p: string) => Promise<boolean>;
+}
+interface ParsedAppJson {
+    expo?: {
+        scheme?: string | string[] | unknown;
+        [k: string]: unknown;
+    };
+    [k: string]: unknown;
+}
+export declare function stripCeraphSchemeFromAppJson(parsed: ParsedAppJson): {
+    changed: boolean;
+    previousScheme: string | string[] | undefined;
+    nextScheme: string | string[] | undefined;
+};
+export declare function revertCeraphUrlScheme(projectDir: string, deps?: RevertSchemeDeps): Promise<RevertSchemeResult>;
+export {};

package/dist/uninstall/revert-scheme.js

@@ -0,0 +1,139 @@
+import { readFile, writeFile, access } from "node:fs/promises";
+import { join } from "node:path";
+export const CERAPH_SCHEME = "ceraph";
+async function defaultExists(p) {
+    try {
+        await access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function stripCeraphSchemeFromAppJson(parsed) {
+    if (!parsed.expo || typeof parsed.expo !== "object") {
+        return { changed: false, previousScheme: undefined, nextScheme: undefined };
+    }
+    const expo = parsed.expo;
+    const current = expo.scheme;
+    if (typeof current === "string") {
+        if (current === CERAPH_SCHEME) {
+            delete expo.scheme;
+            return {
+                changed: true,
+                previousScheme: current,
+                nextScheme: undefined,
+            };
+        }
+        return { changed: false, previousScheme: current, nextScheme: current };
+    }
+    if (Array.isArray(current)) {
+        const hadCeraph = current.includes(CERAPH_SCHEME);
+        if (!hadCeraph) {
+            return {
+                changed: false,
+                previousScheme: [...current],
+                nextScheme: [...current],
+            };
+        }
+        const remaining = current.filter((s) => s !== CERAPH_SCHEME);
+        const previous = [...current];
+        if (remaining.length === 0) {
+            delete expo.scheme;
+            return {
+                changed: true,
+                previousScheme: previous,
+                nextScheme: undefined,
+            };
+        }
+        if (remaining.length === 1) {
+            expo.scheme = remaining[0];
+            return {
+                changed: true,
+                previousScheme: previous,
+                nextScheme: remaining[0],
+            };
+        }
+        expo.scheme = remaining;
+        return {
+            changed: true,
+            previousScheme: previous,
+            nextScheme: remaining,
+        };
+    }
+    return { changed: false, previousScheme: undefined, nextScheme: undefined };
+}
+function parseAppJson(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function serialiseAppJson(parsed, original) {
+    const indentMatch = original.match(/\n(\s+)"/);
+    const indent = indentMatch?.[1] ?? "  ";
+    const hadTrailingNewline = original.endsWith("\n");
+    const output = JSON.stringify(parsed, null, indent);
+    return hadTrailingNewline ? output + "\n" : output;
+}
+const BARE_RN_REMEDIATION = "Remove the ceraph scheme from ios/<App>/Info.plist CFBundleURLTypes and android/app/src/main/AndroidManifest.xml. " +
+    "Both files were never written by init — they require manual edits because they are inside the customer's native project tree.";
+function dynamicConfigRemediation(path) {
+    return (`Your project uses ${path} (dynamic Expo config). The init walkthrough ` +
+        "never edited this file automatically; if you (or a teammate) added `ceraph` " +
+        "to its `scheme` value, remove that entry by hand. After editing, run " +
+        "`expo prebuild --clean` or restart the dev client.");
+}
+export async function revertCeraphUrlScheme(projectDir, deps = {}) {
+    const exists = deps.fileExists ?? defaultExists;
+    const read = deps.readFile ?? ((p) => readFile(p, "utf-8"));
+    const write = deps.writeFile ?? ((p, c) => writeFile(p, c, "utf-8"));
+    const appJsonPath = join(projectDir, "app.json");
+    const appConfigJs = join(projectDir, "app.config.js");
+    const appConfigTs = join(projectDir, "app.config.ts");
+    const iosDir = join(projectDir, "ios");
+    const androidDir = join(projectDir, "android");
+    const hasAppConfigJs = await exists(appConfigJs);
+    const hasAppConfigTs = await exists(appConfigTs);
+    if (hasAppConfigJs || hasAppConfigTs) {
+        const path = hasAppConfigTs ? appConfigTs : appConfigJs;
+        return {
+            status: "manual",
+            kind: "expo-dynamic",
+            path,
+            remediation: dynamicConfigRemediation(path),
+        };
+    }
+    if (await exists(appJsonPath)) {
+        const raw = await read(appJsonPath);
+        const parsed = parseAppJson(raw);
+        if (!parsed) {
+            return { status: "already-reverted", path: appJsonPath };
+        }
+        const { changed, previousScheme, nextScheme } = stripCeraphSchemeFromAppJson(parsed);
+        if (!changed) {
+            return { status: "already-reverted", path: appJsonPath };
+        }
+        await write(appJsonPath, serialiseAppJson(parsed, raw));
+        return {
+            status: "reverted",
+            path: appJsonPath,
+            previousScheme: previousScheme,
+            nextScheme: nextScheme,
+        };
+    }
+    if ((await exists(iosDir)) || (await exists(androidDir))) {
+        return {
+            status: "manual",
+            kind: "bare-rn",
+            remediation: BARE_RN_REMEDIATION,
+        };
+    }
+    return { status: "no-rn-project" };
+}

package/dist/uninstall/revert-signal-host-env.d.ts

@@ -0,0 +1,31 @@
+export interface ShellProfileTarget {
+    path: string;
+    shell: "zsh" | "bash";
+}
+export interface PickProfileDeps {
+    env?: NodeJS.ProcessEnv;
+    home?: string;
+}
+export declare function pickShellProfile(deps?: PickProfileDeps): ShellProfileTarget;
+export type RevertSignalHostEnvResult = {
+    status: "reverted";
+    path: string;
+    shell: "zsh" | "bash";
+    removedIp: string | null;
+} | {
+    status: "already-reverted";
+    path: string;
+    shell: "zsh" | "bash";
+} | {
+    status: "no-profile";
+    path: string;
+    shell: "zsh" | "bash";
+};
+export interface RevertSignalHostEnvDeps {
+    readFile?: (p: string) => Promise<string>;
+    writeFile?: (p: string, c: string) => Promise<void>;
+    target?: ShellProfileTarget;
+    env?: NodeJS.ProcessEnv;
+    home?: string;
+}
+export declare function revertSignalHostEnv(deps?: RevertSignalHostEnvDeps): Promise<RevertSignalHostEnvResult>;

package/dist/uninstall/revert-signal-host-env.js

@@ -0,0 +1,61 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const SENTINEL_HEAD = "# Ceraph signal host — auto-set by @ceraph/react-native-mcp init";
+const SENTINEL_TAIL = "# End Ceraph signal host";
+export function pickShellProfile(deps = {}) {
+    const env = deps.env ?? process.env;
+    const home = deps.home ?? homedir();
+    const shellPath = env.SHELL ?? "";
+    if (shellPath.endsWith("/bash")) {
+        return { path: join(home, ".bashrc"), shell: "bash" };
+    }
+    return { path: join(home, ".zshrc"), shell: "zsh" };
+}
+export async function revertSignalHostEnv(deps = {}) {
+    const target = deps.target ?? pickShellProfile({ env: deps.env, home: deps.home });
+    const read = deps.readFile ?? ((p) => readFile(p, "utf-8"));
+    const write = deps.writeFile ?? ((p, c) => writeFile(p, c, "utf-8"));
+    let body;
+    try {
+        body = await read(target.path);
+    }
+    catch {
+        return { status: "no-profile", path: target.path, shell: target.shell };
+    }
+    const headIdx = body.indexOf(SENTINEL_HEAD);
+    if (headIdx === -1) {
+        return {
+            status: "already-reverted",
+            path: target.path,
+            shell: target.shell,
+        };
+    }
+    const tailIdx = body.indexOf(SENTINEL_TAIL, headIdx);
+    if (tailIdx === -1) {
+        return {
+            status: "already-reverted",
+            path: target.path,
+            shell: target.shell,
+        };
+    }
+    const afterTail = tailIdx + SENTINEL_TAIL.length;
+    const end = body[afterTail] === "\n" ? afterTail + 1 : afterTail;
+    const between = body.slice(headIdx, end);
+    const exportMatch = between.match(/export\s+CERAPH_SIGNAL_HOST=(\S+)/);
+    const removedIp = exportMatch ? exportMatch[1] : null;
+    let start = headIdx;
+    if (start >= 1 && body[start - 1] === "\n") {
+        if (start >= 2 && body[start - 2] === "\n") {
+            start -= 1;
+        }
+    }
+    const next = body.slice(0, start) + body.slice(end);
+    await write(target.path, next);
+    return {
+        status: "reverted",
+        path: target.path,
+        shell: target.shell,
+        removedIp,
+    };
+}

package/dist/uninstall/walkthrough.d.ts

@@ -0,0 +1,80 @@
+import { type MonorepoDetectionResult } from "../init/monorepo.js";
+import { type RevertGitignoreResult } from "./revert-gitignore.js";
+import { type RevertSignalHostEnvResult } from "./revert-signal-host-env.js";
+import { type RevertCeraphDirResult } from "./revert-ceraph-dir.js";
+import { type RevertAuthResult } from "./revert-auth.js";
+import { type RevertSchemeResult } from "./revert-scheme.js";
+import { type RevertMcpClientsResult, type RevertUserGlobalMcpClientsResult } from "./revert-mcp-clients.js";
+import { type RevertClaudeHooksResult } from "./revert-claude-hooks.js";
+import { type RevertBootResult, type RevertBootTarget } from "./revert-boot.js";
+import { type RevertCameraResult } from "./revert-camera.js";
+import { type RevertPackageResult } from "./revert-package.js";
+export type UninstallStepName = "monorepo" | "camera" | "boot" | "scheme" | "mcp-clients" | "claude-hooks" | "gitignore" | "signal-host" | "ceraph-dir" | "auth" | "package";
+export type UninstallStepStatus = "reverted" | "skipped" | "already-reverted" | "warning" | "manual" | "error";
+export interface UninstallStep {
+    name: UninstallStepName;
+    status: UninstallStepStatus;
+    details?: Record<string, unknown>;
+    remediation?: string;
+}
+export interface UninstallWalkthroughSummary {
+    reverted: number;
+    skipped: number;
+    warnings: string[];
+    manualSteps: string[];
+}
+export interface UninstallWalkthroughResult {
+    workingDir: string;
+    steps: UninstallStep[];
+    summary: UninstallWalkthroughSummary;
+}
+export interface UninstallWalkthroughOpts {
+    projectDir: string;
+    purgeImages?: boolean;
+    global?: boolean;
+    dryRun?: boolean;
+    nonInteractive?: boolean;
+    onStep?: (step: UninstallStep) => void;
+    spawnRemove?: (input: {
+        bin: string;
+        args: string[];
+        cwd: string;
+    }) => Promise<{
+        exitCode: number;
+    }>;
+    detectMonorepo?: (projectDir: string) => Promise<MonorepoDetectionResult>;
+    homeDir?: () => string;
+    revertCamera?: (projectDir: string) => Promise<RevertCameraResult>;
+    revertBoot?: (projectDir: string) => Promise<RevertBootResult>;
+    revertCeraphUrlScheme?: (projectDir: string) => Promise<RevertSchemeResult>;
+    revertMcpClients?: (projectDir: string) => Promise<RevertMcpClientsResult>;
+    revertUserGlobalMcpClients?: (deps: {
+        home?: string;
+    }) => Promise<RevertUserGlobalMcpClientsResult>;
+    revertClaudeHooks?: (input: {
+        projectDir: string;
+    }) => Promise<RevertClaudeHooksResult>;
+    revertGitignore?: (projectDir: string) => Promise<RevertGitignoreResult>;
+    revertSignalHostEnv?: (deps?: {
+        home?: string;
+    }) => Promise<RevertSignalHostEnvResult>;
+    revertCeraphDir?: (input: {
+        projectDir: string;
+        confirm: boolean;
+    }) => Promise<RevertCeraphDirResult>;
+    revertAuth?: (input: {
+        global: boolean;
+        home?: string;
+    }) => Promise<RevertAuthResult>;
+    revertPackage?: (projectDir: string, deps: {
+        spawnRemove?: (input: {
+            bin: string;
+            args: string[];
+            cwd: string;
+        }) => Promise<{
+            exitCode: number;
+        }>;
+    }) => Promise<RevertPackageResult>;
+    detectBootTarget?: (projectDir: string) => Promise<RevertBootTarget | null>;
+}
+export declare function runUninstallWalkthrough(opts: UninstallWalkthroughOpts): Promise<UninstallWalkthroughResult>;