@appspacer/cli 1.0.0

package/dist/commands/setup.js

@@ -0,0 +1,575 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import fs from "fs";
+import path from "path";
+import ora from "ora";
+// ─── Marker Constants ────────────────────────────────────────────────────────
+const MARKER_START = "// APPSPACER_START";
+const MARKER_END = "// APPSPACER_END";
+export function detectArchitecture(content) {
+    if (content.includes("ReactHostDelegate") ||
+        content.includes("ReactHostImpl") ||
+        content.includes("getReactHost") ||
+        content.includes("DefaultReactHost")) {
+        return "new";
+    }
+    if (content.includes("ReactNativeHost") ||
+        content.includes("getReactNativeHost") ||
+        content.includes("getJSBundleFile")) {
+        return "traditional";
+    }
+    if (content.includes("DefaultNewArchitectureEntryPoint")) {
+        return "new";
+    }
+    return "traditional";
+}
+// ─── Shared Helpers ──────────────────────────────────────────────────────────
+function searchForFile(dir, fileNames, depth = 8) {
+    if (depth < 0)
+        return null;
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return null;
+    }
+    for (const entry of entries) {
+        if (entry.name === "node_modules" || entry.name.startsWith("."))
+            continue;
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isSymbolicLink())
+            continue;
+        if (entry.isDirectory()) {
+            const result = searchForFile(fullPath, fileNames, depth - 1);
+            if (result)
+                return result;
+        }
+        else if (fileNames.includes(entry.name)) {
+            return fullPath;
+        }
+    }
+    return null;
+}
+export function hasExistingInjection(content) {
+    return content.includes(MARKER_START) && content.includes(MARKER_END);
+}
+export function removeExistingInjection(content) {
+    const startIdx = content.indexOf(MARKER_START);
+    const endIdx = content.indexOf(MARKER_END);
+    if (startIdx === -1 || endIdx === -1)
+        return content;
+    // Go back to the start of the line containing MARKER_START (capture leading whitespace)
+    const lineStart = content.lastIndexOf("\n", startIdx - 1);
+    const endLineIdx = content.indexOf("\n", endIdx + MARKER_END.length);
+    const before = content.substring(0, lineStart === -1 ? 0 : lineStart);
+    const after = endLineIdx !== -1 ? content.substring(endLineIdx + 1) : "";
+    // Remove one leading blank line to avoid double blank lines after removal
+    return (before + "\n" + after).replace(/\n{3,}/g, "\n\n");
+}
+function writeWithBackup(filePath, modified) {
+    const backupPath = filePath + ".appspacer.bak";
+    // Only create backup if one doesn't already exist (preserve original)
+    if (!fs.existsSync(backupPath)) {
+        fs.copyFileSync(filePath, backupPath);
+    }
+    fs.writeFileSync(filePath, modified, "utf-8");
+}
+function isPackageInstalled(projectDir) {
+    const nodeModulesPath = path.join(projectDir, "node_modules", "@appspacer/react-native");
+    return fs.existsSync(nodeModulesPath);
+}
+// ─── Android Setup ──────────────────────────────────────────────────────────
+function findMainApplication(androidDir) {
+    const srcDirs = [
+        path.join(androidDir, "app", "src", "main", "java"),
+        path.join(androidDir, "app", "src", "main", "kotlin"),
+    ];
+    for (const srcDir of srcDirs) {
+        if (!fs.existsSync(srcDir))
+            continue;
+        // Search for both Kotlin and Java variants
+        const result = searchForFile(srcDir, ["MainApplication.kt", "MainApplication.java"]);
+        if (result)
+            return result;
+    }
+    return null;
+}
+function getTraditionalAndroidInjection() {
+    return `
+    ${MARKER_START}
+    // AppSpacer OTA — Dynamic bundle resolution (Traditional Architecture)
+    override fun getJSBundleFile(): String? =
+        com.appspacer.AppSpacerModule.getCustomBundlePath(applicationContext)
+    ${MARKER_END}`;
+}
+function getNewArchAndroidInjection() {
+    return `
+    ${MARKER_START}
+    // AppSpacer OTA — Dynamic bundle resolution (New Architecture)
+    override fun getJsBundleFilePath(): String? =
+        com.appspacer.AppSpacerModule.getCustomBundlePath(applicationContext)
+    ${MARKER_END}`;
+}
+/**
+ * Safely injects code INSIDE a matched block's opening brace,
+ * rather than using lastIndexOf("}") which can target the wrong brace.
+ */
+function injectAfterOpenBrace(content, pattern, injection) {
+    const match = content.match(pattern);
+    if (!match || match.index === undefined)
+        return null;
+    const insertPos = match.index + match[0].length;
+    return content.substring(0, insertPos) + injection + content.substring(insertPos);
+}
+/**
+ * Injects before the OUTER class closing brace by tracking brace depth,
+ * rather than blindly using lastIndexOf("}").
+ */
+function injectBeforeClassEnd(content, injection, classPattern) {
+    const classMatch = content.match(classPattern);
+    if (!classMatch || classMatch.index === undefined) {
+        throw new Error(`Could not locate the class declaration matching ${classPattern}. ` +
+            "Please add the AppSpacer bundle resolver manually.");
+    }
+    // Walk from class opening brace, track depth to find the closing brace
+    let depth = 0;
+    let classBodyStart = -1;
+    for (let i = classMatch.index; i < content.length; i++) {
+        if (content[i] === "{") {
+            depth++;
+            if (depth === 1)
+                classBodyStart = i;
+        }
+        else if (content[i] === "}") {
+            depth--;
+            if (depth === 0 && classBodyStart !== -1) {
+                return (content.substring(0, i) +
+                    "\n" + injection + "\n" +
+                    content.substring(i));
+            }
+        }
+    }
+    throw new Error("Could not find the closing brace of the class. " +
+        "Please add the AppSpacer bundle resolver manually.");
+}
+export function injectTraditionalAndroid(content) {
+    const injection = getTraditionalAndroidInjection();
+    // Pattern 1: Inline ReactNativeHost object
+    const hostPattern = /object\s*:\s*(?:Default)?ReactNativeHost\s*\(.*?\)\s*\{/s;
+    const result = injectAfterOpenBrace(content, hostPattern, injection);
+    if (result)
+        return { result, method: "ReactNativeHost block" };
+    // Pattern 2: class-level fallback using brace tracking
+    const classPattern = /class\s+MainApplication\b[^{]*\{/;
+    return {
+        result: injectBeforeClassEnd(content, injection, classPattern),
+        method: "class body (fallback)",
+    };
+}
+export function injectNewArchAndroid(content) {
+    const injection = getNewArchAndroidInjection();
+    // Pattern 1: Inline ReactHostDelegate object expression
+    const delegatePattern = /object\s*:\s*ReactHostDelegate\s*\{/;
+    const result1 = injectAfterOpenBrace(content, delegatePattern, injection);
+    if (result1)
+        return { result: result1, method: "ReactHostDelegate block" };
+    // Pattern 2: reactHost lazy block containing DefaultReactHostDelegate
+    const reactHostPattern = /override\s+val\s+reactHost\s*[^{]*\{/;
+    const result2 = injectAfterOpenBrace(content, reactHostPattern, injection);
+    if (result2)
+        return { result: result2, method: "reactHost lazy block" };
+    // Pattern 3: DefaultReactHost.getDefaultReactHost — inject real commented
+    // instructions with a warning (can't auto-patch this pattern)
+    const defaultHostPattern = /DefaultReactHost\s*\.\s*getDefaultReactHost/;
+    if (defaultHostPattern.test(content)) {
+        const classPattern = /class\s+MainApplication\b[^{]*\{/;
+        const manualInjection = `
+    ${MARKER_START}
+    // AppSpacer OTA — ACTION REQUIRED (DefaultReactHost pattern detected)
+    //
+    // Automatic injection is not possible for this pattern.
+    // Please manually replace your reactHost initialisation with:
+    //
+    //   override val reactHost: ReactHost by lazy {
+    //       val delegate = object : ReactHostDelegate {
+    //           override fun getJsBundleFilePath(): String? =
+    //               com.appspacer.AppSpacerModule.getCustomBundlePath(applicationContext)
+    //           override fun getJsMainModulePath(): String = "index"
+    //           override fun getReactPackages(): List<ReactPackage> =
+    //               PackageList(this@MainApplication).packages
+    //       }
+    //       ReactHostImpl(applicationContext, delegate, SurfaceDelegateFactory { null }, true, true)
+    //   }
+    ${MARKER_END}`;
+        return {
+            result: injectBeforeClassEnd(content, manualInjection, classPattern),
+            method: "DefaultReactHost pattern",
+            warn: "DefaultReactHost pattern detected — manual action required. A comment block with instructions has been injected.",
+        };
+    }
+    // Fallback: inject at class body level
+    const classPattern = /class\s+MainApplication\b[^{]*\{/;
+    return {
+        result: injectBeforeClassEnd(content, injection, classPattern),
+        method: "class body (fallback)",
+    };
+}
+// ─── iOS Setup ──────────────────────────────────────────────────────────────
+function findAppDelegate(iosDir) {
+    // Check flat root first
+    for (const name of ["AppDelegate.mm", "AppDelegate.swift", "AppDelegate.m"]) {
+        const p = path.join(iosDir, name);
+        if (fs.existsSync(p))
+            return p;
+    }
+    // Search one level deep in subdirectories
+    const entries = fs.readdirSync(iosDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const subDir = path.join(iosDir, entry.name);
+        for (const name of ["AppDelegate.mm", "AppDelegate.swift", "AppDelegate.m"]) {
+            const p = path.join(subDir, name);
+            if (fs.existsSync(p))
+                return p;
+        }
+    }
+    return null;
+}
+export function injectIosSetup(content, filePath) {
+    if (hasExistingInjection(content)) {
+        content = removeExistingInjection(content);
+    }
+    return filePath.endsWith(".swift")
+        ? injectIosSwift(content)
+        : injectIosObjC(content);
+}
+function injectIosObjC(content) {
+    // Ensure #import <AppSpacerModule.h> is present
+    if (!content.includes("AppSpacerModule.h")) {
+        const lastImportIdx = content.lastIndexOf("#import");
+        if (lastImportIdx !== -1) {
+            const lineEnd = content.indexOf("\n", lastImportIdx);
+            content =
+                content.substring(0, lineEnd + 1) +
+                    `#import <AppSpacerModule.h>\n` +
+                    content.substring(lineEnd + 1);
+        }
+        else {
+            content = `#import <AppSpacerModule.h>\n${content}`;
+        }
+    }
+    const replacement = `
+  ${MARKER_START}
+  // AppSpacer OTA — Dynamic bundle URL resolution
+  return [AppSpacerModule bundleURL];
+  ${MARKER_END}
+}`;
+    // Pattern 1: RN 0.72 and earlier — bundleURL method
+    const bundleUrlPattern = /(-\s*\(NSURL\s*\*\s*\)\s*bundleURL\s*\{)([\s\S]*?)(\n\})/;
+    const bundleMatch = content.match(bundleUrlPattern);
+    if (bundleMatch && bundleMatch.index !== undefined) {
+        return {
+            result: content.substring(0, bundleMatch.index) +
+                `${bundleMatch[1]}\n${replacement}` +
+                content.substring(bundleMatch.index + bundleMatch[0].length),
+        };
+    }
+    // Pattern 2: RN 0.73+ — sourceURLForBridge method
+    const sourceUrlPattern = /(-\s*\(NSURL\s*\*\s*\)\s*sourceURLForBridge\s*:\s*\(RCTBridge\s*\*\s*\)\s*\w+\s*\{)([\s\S]*?)(\n\})/;
+    const sourceMatch = content.match(sourceUrlPattern);
+    if (sourceMatch && sourceMatch.index !== undefined) {
+        return {
+            result: content.substring(0, sourceMatch.index) +
+                `${sourceMatch[1]}\n${replacement}` +
+                content.substring(sourceMatch.index + sourceMatch[0].length),
+        };
+    }
+    // Fallback: inject a new bundleURL method before @end
+    const endIdx = content.lastIndexOf("@end");
+    if (endIdx !== -1) {
+        const bundleMethod = `
+${MARKER_START}
+// AppSpacer OTA — Dynamic bundle URL resolution
+- (NSURL *)bundleURL {
+  return [AppSpacerModule bundleURL];
+}
+${MARKER_END}
+
+`;
+        return {
+            result: content.substring(0, endIdx) + bundleMethod + content.substring(endIdx),
+            warn: "bundleURL / sourceURLForBridge method not found — injected a new bundleURL method before @end. Verify it doesn't conflict with an existing implementation.",
+        };
+    }
+    return {
+        result: content,
+        warn: "Could not find a suitable injection point in AppDelegate.mm — please add the bundleURL method manually.",
+    };
+}
+function injectIosSwift(content) {
+    // Swift AppDelegate: ObjC native modules are exposed via the bridging header,
+    // no explicit `import AppSpacerModule` is needed or valid.
+    const replacement = `
+    ${MARKER_START}
+    // AppSpacer OTA — Dynamic bundle URL resolution
+    return AppSpacerModule.bundleURL()
+    ${MARKER_END}
+  }`;
+    // Pattern 1: bundleURL override
+    const bundleUrlPattern = /(override\s+func\s+bundleURL\s*\(\s*\)\s*->\s*URL\??\s*\{)([\s\S]*?)(\n\s*\})/;
+    const bundleMatch = content.match(bundleUrlPattern);
+    if (bundleMatch && bundleMatch.index !== undefined) {
+        return {
+            result: content.substring(0, bundleMatch.index) +
+                `${bundleMatch[1]}\n${replacement}` +
+                content.substring(bundleMatch.index + bundleMatch[0].length),
+        };
+    }
+    // Pattern 2: sourceURL(for:) override (RN 0.73+)
+    const sourceUrlPattern = /(override\s+func\s+sourceURL\s*\(for\s+bridge\s*:[^)]*\)\s*->\s*URL\??\s*\{)([\s\S]*?)(\n\s*\})/;
+    const sourceMatch = content.match(sourceUrlPattern);
+    if (sourceMatch && sourceMatch.index !== undefined) {
+        return {
+            result: content.substring(0, sourceMatch.index) +
+                `${sourceMatch[1]}\n${replacement}` +
+                content.substring(sourceMatch.index + sourceMatch[0].length),
+        };
+    }
+    // Fallback: inject before the last closing brace of the class
+    const classPattern = /class\s+AppDelegate\b[^{]*\{/;
+    const classMatch = content.match(classPattern);
+    if (classMatch) {
+        const bundleMethod = `
+  ${MARKER_START}
+  // AppSpacer OTA — Dynamic bundle URL resolution
+  override func bundleURL() -> URL? {
+    return AppSpacerModule.bundleURL()
+  }
+  ${MARKER_END}`;
+        return {
+            result: injectBeforeClassEnd(content, bundleMethod, classPattern),
+            warn: "bundleURL / sourceURL method not found in Swift AppDelegate — injected a new override. Verify it is correct for your RN version.",
+        };
+    }
+    return {
+        result: content,
+        warn: "Could not find AppDelegate class in Swift file — please add the bundleURL override manually.",
+    };
+}
+// ─── Undo Command ────────────────────────────────────────────────────────────
+export const undoCommand = new Command("setup:undo")
+    .description("Remove AppSpacer injections from native files")
+    .option("--project-dir <dir>", "Root directory of the React Native project", ".")
+    .action((opts) => {
+    const projectDir = path.resolve(opts.projectDir);
+    console.log("");
+    console.log(chalk.bold.hex("#7C3AED")("  ╔══════════════════════════════════════╗"));
+    console.log(chalk.bold.hex("#7C3AED")("  ║     🔄  AppSpacer Setup Undo        ║"));
+    console.log(chalk.bold.hex("#7C3AED")("  ╚══════════════════════════════════════╝"));
+    console.log("");
+    const filesToCheck = [];
+    const androidDir = path.join(projectDir, "android");
+    if (fs.existsSync(androidDir)) {
+        const mainApp = findMainApplication(androidDir);
+        if (mainApp)
+            filesToCheck.push(mainApp);
+    }
+    const iosDir = path.join(projectDir, "ios");
+    if (fs.existsSync(iosDir)) {
+        const appDelegate = findAppDelegate(iosDir);
+        if (appDelegate)
+            filesToCheck.push(appDelegate);
+    }
+    let cleaned = 0;
+    for (const filePath of filesToCheck) {
+        const content = fs.readFileSync(filePath, "utf-8");
+        if (!hasExistingInjection(content)) {
+            console.log(chalk.dim(`  — No injection found in ${path.relative(projectDir, filePath)}`));
+            continue;
+        }
+        const cleaned_content = removeExistingInjection(content);
+        fs.writeFileSync(filePath, cleaned_content, "utf-8");
+        console.log(chalk.green(`  ✔ Removed injection from ${path.relative(projectDir, filePath)}`));
+        cleaned++;
+    }
+    if (cleaned === 0) {
+        console.log(chalk.yellow("\n  No AppSpacer injections found in any native files.\n"));
+    }
+    else {
+        console.log(chalk.green.bold(`\n  ✔ Removed ${cleaned} injection(s). Rebuild your app to apply.\n`));
+    }
+});
+// ─── Main Setup Command ─────────────────────────────────────────────────────
+export const setupCommand = new Command("setup")
+    .description("Auto-configure native files for AppSpacer OTA updates")
+    .option("--android-only", "Only configure Android")
+    .option("--ios-only", "Only configure iOS")
+    .option("--project-dir <dir>", "Root directory of the React Native project", ".")
+    .option("--dry-run", "Preview changes without writing files")
+    .action(async (opts) => {
+    const projectDir = path.resolve(opts.projectDir);
+    console.log("");
+    console.log(chalk.bold.hex("#7C3AED")("  ╔══════════════════════════════════════╗"));
+    console.log(chalk.bold.hex("#7C3AED")("  ║       🚀 AppSpacer Auto Setup       ║"));
+    console.log(chalk.bold.hex("#7C3AED")("  ╚══════════════════════════════════════╝"));
+    console.log("");
+    // ── SDK check ────────────────────────────────────────────
+    if (!isPackageInstalled(projectDir)) {
+        console.log(chalk.yellow.bold("  ⚠  react-native-appspacer is not installed in node_modules."));
+        console.log(chalk.dim("     Run: npm install react-native-appspacer  (or yarn add)"));
+        console.log(chalk.dim("     Then re-run: appspacer setup\n"));
+        process.exit(1);
+    }
+    let androidSuccess = false;
+    let iosSuccess = false;
+    // ── Android ──────────────────────────────────────────────
+    if (!opts.iosOnly) {
+        const spinner = ora({
+            text: "Detecting Android project structure...",
+            color: "cyan",
+        }).start();
+        const androidDir = path.join(projectDir, "android");
+        if (!fs.existsSync(androidDir)) {
+            spinner.warn(chalk.yellow("Android directory not found — skipping Android setup"));
+        }
+        else {
+            const mainAppPath = findMainApplication(androidDir);
+            if (!mainAppPath) {
+                spinner.fail(chalk.red("Could not find MainApplication.kt or MainApplication.java"));
+            }
+            else {
+                const fileName = path.basename(mainAppPath);
+                spinner.succeed(chalk.green(`Found ${fileName}`) +
+                    chalk.dim(` (${path.relative(projectDir, mainAppPath)})`));
+                let content = fs.readFileSync(mainAppPath, "utf-8");
+                if (hasExistingInjection(content)) {
+                    const reapplySpinner = ora({
+                        text: "Removing previous AppSpacer injection...",
+                        color: "yellow",
+                    }).start();
+                    content = removeExistingInjection(content);
+                    reapplySpinner.succeed(chalk.green("Cleaned previous injection"));
+                }
+                const archSpinner = ora({
+                    text: "Detecting React Native architecture...",
+                    color: "cyan",
+                }).start();
+                const arch = detectArchitecture(content);
+                archSpinner.succeed(chalk.green("Detected architecture: ") +
+                    chalk.bold(arch === "new"
+                        ? "New Architecture (ReactHostDelegate)"
+                        : "Traditional (ReactNativeHost)"));
+                const injectSpinner = ora({
+                    text: "Injecting AppSpacer bundle resolver...",
+                    color: "cyan",
+                }).start();
+                const injectResult = arch === "new"
+                    ? injectNewArchAndroid(content)
+                    : injectTraditionalAndroid(content);
+                if (injectResult.warn) {
+                    injectSpinner.warn(chalk.yellow(injectResult.warn));
+                }
+                if (opts.dryRun) {
+                    injectSpinner.info(chalk.blue("Dry run — no files modified"));
+                    console.log(chalk.dim("\n--- Preview (Android) ---\n"));
+                    const startIdx = injectResult.result.indexOf(MARKER_START);
+                    const endIdx = injectResult.result.indexOf(MARKER_END) + MARKER_END.length;
+                    if (startIdx !== -1 && endIdx > MARKER_END.length) {
+                        console.log(chalk.cyan(injectResult.result.substring(startIdx, endIdx)));
+                    }
+                    console.log("");
+                }
+                else {
+                    // Bail on manual-only patterns — don't write a file that "looks" patched but isn't
+                    if (injectResult.warn && injectResult.warn.includes("ACTION REQUIRED")) {
+                        injectSpinner.warn(chalk.yellow("Android file written with instruction comment — manual steps required above."));
+                        writeWithBackup(mainAppPath, injectResult.result);
+                        // Still mark as "handled" so summary is shown, but flag it
+                        androidSuccess = true;
+                    }
+                    else {
+                        writeWithBackup(mainAppPath, injectResult.result);
+                        injectSpinner.succeed(chalk.green(`Android setup complete`) +
+                            chalk.dim(` via ${injectResult.method}`));
+                        androidSuccess = true;
+                    }
+                }
+            }
+        }
+    }
+    // ── iOS ──────────────────────────────────────────────────
+    if (!opts.androidOnly) {
+        const spinner = ora({
+            text: "Detecting iOS project structure...",
+            color: "cyan",
+        }).start();
+        const iosDir = path.join(projectDir, "ios");
+        if (!fs.existsSync(iosDir)) {
+            spinner.warn(chalk.yellow("iOS directory not found — skipping iOS setup"));
+        }
+        else {
+            const appDelegatePath = findAppDelegate(iosDir);
+            if (!appDelegatePath) {
+                spinner.fail(chalk.red("Could not find AppDelegate.mm, AppDelegate.m, or AppDelegate.swift"));
+            }
+            else {
+                const ext = path.extname(appDelegatePath);
+                const lang = ext === ".swift" ? "Swift" : "Obj-C";
+                spinner.succeed(chalk.green(`Found AppDelegate${ext}`) +
+                    chalk.dim(` (${lang}) (${path.relative(projectDir, appDelegatePath)})`));
+                const content = fs.readFileSync(appDelegatePath, "utf-8");
+                const injectSpinner = ora({
+                    text: "Injecting AppSpacer bundle URL resolver...",
+                    color: "cyan",
+                }).start();
+                const { result: modified, warn } = injectIosSetup(content, appDelegatePath);
+                if (warn) {
+                    injectSpinner.warn(chalk.yellow(warn));
+                }
+                if (opts.dryRun) {
+                    injectSpinner.info(chalk.blue("Dry run — no files modified"));
+                    console.log(chalk.dim("\n--- Preview (iOS) ---\n"));
+                    const startIdx = modified.indexOf(MARKER_START);
+                    const endIdx = modified.indexOf(MARKER_END) + MARKER_END.length;
+                    if (startIdx !== -1 && endIdx > MARKER_END.length) {
+                        console.log(chalk.cyan(modified.substring(startIdx, endIdx)));
+                    }
+                    console.log("");
+                }
+                else {
+                    writeWithBackup(appDelegatePath, modified);
+                    if (!warn) {
+                        injectSpinner.succeed(chalk.green("iOS setup complete"));
+                    }
+                    iosSuccess = true;
+                }
+            }
+        }
+    }
+    // ── Summary ──────────────────────────────────────────────
+    console.log("");
+    if (opts.dryRun) {
+        console.log(chalk.blue.bold("  ℹ  Dry run complete — no files were modified."));
+        console.log(chalk.dim("     Run again without --dry-run to apply changes.\n"));
+    }
+    else if (androidSuccess || iosSuccess) {
+        console.log(chalk.green.bold("  ✔  AppSpacer setup complete!"));
+        if (androidSuccess)
+            console.log(chalk.dim("     ✔ Android — bundle resolver injected (backup saved as .appspacer.bak)"));
+        if (iosSuccess)
+            console.log(chalk.dim("     ✔ iOS     — bundle URL resolver injected (backup saved as .appspacer.bak)"));
+        console.log("");
+        console.log(chalk.dim("  Next steps:"));
+        console.log(chalk.dim("    1. Rebuild your app") + chalk.dim(" (npx react-native run-android / run-ios)"));
+        console.log(chalk.dim("    2. Wrap your root component with ") + chalk.cyan("withAppSpacer()"));
+        console.log(chalk.dim("    3. Push an update with ") + chalk.cyan("appspacer release-react-native"));
+        console.log(chalk.dim("    4. To undo all changes run ") + chalk.cyan("appspacer setup:undo"));
+        console.log("");
+    }
+    else {
+        console.log(chalk.red.bold("  ✗  Setup failed. See errors above.\n"));
+        process.exit(1);
+    }
+});

package/dist/commands/vault.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const vaultCommand: Command;