@appspacer/cli 1.0.0

package/dist/commands/login.js

@@ -0,0 +1,41 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import readline from "node:readline";
+import { saveConfig, getApiUrl } from "../config.js";
+import { apiRequest } from "../api.js";
+export const loginCommand = new Command("login")
+    .description("Authenticate with AppSpacer using a Personal Access Token")
+    .option("-t, --token <token>", "Personal Access Token")
+    .option("--api-url <url>", "API base URL")
+    .action(async (opts) => {
+    try {
+        const apiUrl = opts.apiUrl || getApiUrl();
+        if (opts.apiUrl)
+            saveConfig({ apiUrl: opts.apiUrl });
+        let accessToken = opts.token;
+        if (!accessToken) {
+            // Interactive prompt for Token
+            // console.log(chalk.cyan(`\nTo authenticate, please generate a token at:`));
+            // console.log(chalk.bold.underline(`  ${apiUrl.replace("/api", "")}/settings/tokens\n`));
+            const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+            const ask = (q) => new Promise((r) => rl.question(q, r));
+            accessToken = await ask(chalk.green("? ") + chalk.bold("Enter your Personal Access Token: "));
+            rl.close();
+            if (!accessToken || !accessToken.startsWith("pat_")) {
+                console.error(chalk.red("✗ Invalid token format. Support tokens start with 'pat_'"));
+                process.exit(1);
+            }
+        }
+        // 1. Save the token
+        saveConfig({ accessToken });
+        // 2. Verify and show whoami info
+        console.log(chalk.dim("Verifying session..."));
+        const user = await apiRequest("/profile");
+        const displayName = `${user.first_name || ""} ${user.last_name || ""}`.trim() || user.email;
+        console.log(chalk.green(`\n✓ Logged in as ${chalk.bold(displayName)} (${user.email})`));
+    }
+    catch (err) {
+        console.error(chalk.red(`✗ ${err.message}`));
+        process.exit(1);
+    }
+});

package/dist/commands/release-flutter.d.ts

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

package/dist/commands/release-flutter.js

@@ -0,0 +1,176 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import fs from "fs";
+import path from "path";
+import ora from "ora";
+import { apiRequest } from "../api.js";
+import { stepLabel, printSummary } from "../utils/ui.js";
+import { requireValidPlatform, requireValidDeployment, requireNonEmpty } from "../utils/validators.js";
+import { computeFileHash } from "../utils/hash.js";
+import { createZip } from "../utils/zip.js";
+const TEMP_ZIP = ".ota-flutter-assets.zip";
+function getFlutterVersionFromPubspec() {
+    try {
+        const pubspecPath = path.join(process.cwd(), "pubspec.yaml");
+        if (!fs.existsSync(pubspecPath))
+            return null;
+        const content = fs.readFileSync(pubspecPath, "utf-8");
+        const match = content.match(/^version:\s*([^\s+]+)/m);
+        if (match && match[1])
+            return match[1].trim();
+    }
+    catch {
+        // ignore
+    }
+    return null;
+}
+export const releaseFlutterCommand = new Command("release-flutter")
+    .description("Upload an AppSpacer OTA update for Flutter apps")
+    .requiredOption("-a, --app <appIdOrName>", "App ID or Name")
+    .requiredOption("-d, --deployment <name>", "Deployment name (e.g. Staging, Production)")
+    .requiredOption("-p, --platform <os>", "Target platform (android | ios)")
+    .option("-f, --file <path>", "Path to zipped assets OR assets directory (auto-detects 'assets/' if omitted)")
+    .option("-t, --target-version <version>", "Target app binary version (auto-detected from pubspec.yaml if omitted)")
+    .option("--description <text>", "Release description")
+    .option("--mandatory", "Mark update as mandatory", false)
+    .option("--scheduled-at <datetime>", "Schedule the release (ISO 8601)")
+    .option("--rollout <percentage>", "Rollout percentage (0-100)", "100")
+    .addHelpText("after", `
+Examples:
+  $ appspacer release-flutter -p android -a my-app -d Staging
+  $ appspacer release-flutter -p ios -a my-app -d Production --mandatory -t 1.2.0
+  $ appspacer release-flutter -p android -a my-app -d Staging -f ./custom-assets.zip`)
+    .action(async (opts) => {
+    // ── Validate inputs ─────────────────────────────────────
+    requireValidPlatform(opts.platform);
+    requireNonEmpty(opts.app, "App ID");
+    requireValidDeployment(opts.deployment);
+    let filePath = opts.file ? path.resolve(opts.file) : null;
+    let isTemporaryZip = false;
+    try {
+        // ── Step 1: Resolve / package assets ───────────────────
+        if (!filePath) {
+            const defaultAssetsDir = path.resolve("assets");
+            if (fs.existsSync(defaultAssetsDir) && fs.statSync(defaultAssetsDir).isDirectory()) {
+                console.log(chalk.blue("  ℹ  No file provided — auto-detecting assets/ directory"));
+                filePath = path.resolve(TEMP_ZIP);
+                isTemporaryZip = true;
+                const zipSpinner = ora(stepLabel(1, 3, "Packaging assets/ directory...")).start();
+                try {
+                    await createZip(defaultAssetsDir, filePath);
+                    zipSpinner.succeed(stepLabel(1, 3, "Assets packaged"));
+                }
+                catch (err) {
+                    zipSpinner.fail(stepLabel(1, 3, "Packaging failed"));
+                    throw err;
+                }
+            }
+            else {
+                console.error(chalk.red("  ✗ No file provided and assets/ directory not found."));
+                console.log(chalk.dim("    Provide a file with -f or run from a Flutter project root."));
+                process.exit(1);
+            }
+        }
+        else if (fs.statSync(filePath).isDirectory()) {
+            const sourceDir = filePath;
+            filePath = path.resolve(TEMP_ZIP);
+            isTemporaryZip = true;
+            const zipSpinner = ora(stepLabel(1, 3, `Packaging ${path.basename(sourceDir)}/...`)).start();
+            try {
+                await createZip(sourceDir, filePath);
+                zipSpinner.succeed(stepLabel(1, 3, "Directory packaged"));
+            }
+            catch (err) {
+                zipSpinner.fail(stepLabel(1, 3, "Packaging failed"));
+                throw err;
+            }
+        }
+        if (!fs.existsSync(filePath)) {
+            console.error(chalk.red(`  ✗ File not found: ${filePath}`));
+            process.exit(1);
+        }
+        const filename = isTemporaryZip ? "assets.zip" : path.basename(filePath);
+        const fileSize = fs.statSync(filePath).size;
+        const bundleHash = computeFileHash(filePath);
+        // Resolve target version
+        let targetVersion = opts.targetVersion;
+        if (!targetVersion) {
+            targetVersion = getFlutterVersionFromPubspec();
+            if (targetVersion) {
+                console.log(chalk.dim(`  ℹ  Auto-detected version ${chalk.white(targetVersion)} from pubspec.yaml`));
+            }
+            else {
+                console.error(chalk.red("  ✗ Could not auto-detect version. Provide -t explicitly."));
+                process.exit(1);
+            }
+        }
+        // ── Step 2: Upload ──────────────────────────────────────
+        const uploadSpinner = ora(stepLabel(2, 3, `Uploading ${filename} (${(fileSize / 1024).toFixed(1)} KB)...`)).start();
+        let uploadData;
+        try {
+            uploadData = await apiRequest("/codepush/upload-url", {
+                method: "POST",
+                body: JSON.stringify({ app_id: opts.app, deployment: opts.deployment, filename }),
+            });
+        }
+        catch (err) {
+            uploadSpinner.fail(stepLabel(2, 3, "Failed to get upload URL"));
+            throw err;
+        }
+        // Read file into buffer — reliable across all Node 18+ environments,
+        // avoids the ReadableStream + duplex:"half" workaround.
+        const fileBuffer = fs.readFileSync(filePath);
+        const uploadRes = await fetch(uploadData.signedUrl, {
+            method: "PUT",
+            headers: {
+                "Content-Type": "application/zip",
+                "Content-Length": String(fileSize),
+            },
+            body: fileBuffer,
+        });
+        if (!uploadRes.ok) {
+            uploadSpinner.fail(stepLabel(2, 3, "Upload failed"));
+            const errText = await uploadRes.text();
+            throw new Error(`Upload failed: ${errText}`);
+        }
+        uploadSpinner.succeed(stepLabel(2, 3, "Uploaded"));
+        // ── Step 3: Create release ──────────────────────────────
+        const releaseSpinner = ora(stepLabel(3, 3, "Creating release...")).start();
+        const release = await apiRequest("/codepush/release", {
+            method: "POST",
+            body: JSON.stringify({
+                app_id: opts.app,
+                deployment: opts.deployment,
+                platform: opts.platform,
+                target_binary_range: targetVersion,
+                description: opts.description || "",
+                is_mandatory: opts.mandatory,
+                bundle_url: uploadData.publicUrl,
+                bundle_hash: bundleHash,
+                package_size: fileSize,
+                scheduled_at: opts.scheduledAt,
+                rollout_pct: opts.rollout ? parseInt(opts.rollout) : 100,
+            }),
+        });
+        releaseSpinner.succeed(stepLabel(3, 3, "Release created"));
+        printSummary("Flutter release published", [
+            ["Platform", opts.platform],
+            ["Deployment", opts.deployment],
+            ["Target", targetVersion],
+            ["Mandatory", opts.mandatory ? chalk.yellow("yes") : "no"],
+            ["Rollout", `${opts.rollout ?? 100}%`],
+            ["Size", `${(fileSize / 1024).toFixed(1)} KB`],
+            ["Hash", bundleHash.slice(0, 16) + "…"],
+            ["Release ID", String(release.id)],
+        ]);
+    }
+    catch (err) {
+        console.error(chalk.red(`\n  ✗ ${err.message}`));
+        process.exit(1);
+    }
+    finally {
+        if (isTemporaryZip && filePath && fs.existsSync(filePath)) {
+            fs.unlinkSync(filePath);
+        }
+    }
+});

package/dist/commands/release-react-native.d.ts

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

package/dist/commands/release-react-native.js

@@ -0,0 +1,143 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import fs from "fs";
+import path from "path";
+import { runReactNativeBundle } from "../utils/bundle.js";
+import { createZip } from "../utils/zip.js";
+import { computeFileHash } from "../utils/hash.js";
+import { apiRequest } from "../api.js";
+import { stepLabel, printSummary } from "../utils/ui.js";
+import { requireValidPlatform, requireValidDeployment, requireValidVersion, requireNonEmpty, requireValidRollout } from "../utils/validators.js";
+const BUILD_DIR = ".ota-build";
+const ZIP_FILENAME = "update.zip";
+export const releaseReactNativeCommand = new Command("release-react-native")
+    .description("Bundle, package, and upload a React Native OTA update")
+    .argument("<platform>", "Target platform (android | ios)")
+    .requiredOption("-a, --app <appIdOrName>", "App ID or Name")
+    .requiredOption("-d, --deployment <name>", "Deployment name (e.g. Staging, Production)")
+    .requiredOption("-t, --target-version <version>", "Target app version (e.g. 1.0.0)")
+    .option("--description <text>", "Release description")
+    .option("--mandatory", "Mark update as mandatory", false)
+    .option("--include-assets", "Include assets in the bundle (increases size significantly)", false)
+    .option("--scheduled-at <datetime>", "Schedule the release (ISO 8601)")
+    .option("--rollout <percentage>", "Rollout percentage (0-100)", "100")
+    .addHelpText("after", `
+Examples:
+  $ appspacer release-react-native android -a my-app -d Staging -t 1.0.0
+  $ appspacer release-react-native ios -a my-app -d Production -t 2.1.0 --mandatory
+  $ appspacer release-react-native android -a my-app -d Staging -t 1.0.0 --rollout 20`)
+    .action(async (platform, opts) => {
+    // ── Validate inputs ─────────────────────────────────────
+    requireValidPlatform(platform);
+    requireNonEmpty(opts.app, "App ID");
+    requireValidDeployment(opts.deployment);
+    requireValidVersion(opts.targetVersion);
+    const rolloutPct = requireValidRollout(opts.rollout);
+    const buildDir = path.resolve(BUILD_DIR);
+    const zipPath = path.resolve(`${BUILD_DIR}.zip`);
+    try {
+        // ── Step 1: Bundle ──────────────────────────────────────
+        const bundleSpinner = ora(stepLabel(1, 4, "Bundling React Native app...")).start();
+        try {
+            runReactNativeBundle(platform, buildDir, opts.includeAssets);
+            bundleSpinner.succeed(stepLabel(1, 4, "Bundle created"));
+        }
+        catch (err) {
+            bundleSpinner.fail(stepLabel(1, 4, "Bundling failed"));
+            throw err;
+        }
+        // ── Step 2: Zip ─────────────────────────────────────────
+        const zipSpinner = ora(stepLabel(2, 4, "Packaging update...")).start();
+        let zipSize = 0;
+        try {
+            await createZip(buildDir, zipPath);
+            zipSize = fs.statSync(zipPath).size;
+            zipSpinner.succeed(stepLabel(2, 4, `Packaged  ${chalk.dim(`(${(zipSize / 1024).toFixed(1)} KB)`)}`));
+        }
+        catch (err) {
+            zipSpinner.fail(stepLabel(2, 4, "Packaging failed"));
+            throw err;
+        }
+        // ── Step 3: Hash ────────────────────────────────────────
+        const hashSpinner = ora(stepLabel(3, 5, "Calculating hash...")).start();
+        const bundleHash = computeFileHash(zipPath);
+        hashSpinner.succeed(stepLabel(3, 5, `Hash  ${chalk.dim(bundleHash.slice(0, 16) + "…")}`));
+        // ── Step 4: Upload ──────────────────────────────────────
+        const uploadSpinner = ora(stepLabel(4, 5, `Uploading (${(zipSize / 1024).toFixed(1)} KB)...`)).start();
+        let uploadData;
+        try {
+            uploadData = await apiRequest("/codepush/upload-url", {
+                method: "POST",
+                body: JSON.stringify({
+                    app_id: opts.app,
+                    deployment: opts.deployment,
+                    filename: ZIP_FILENAME,
+                }),
+            });
+        }
+        catch (err) {
+            uploadSpinner.fail(stepLabel(4, 5, "Failed to get upload URL"));
+            throw err;
+        }
+        // Read file into buffer — reliable across all Node 18+ environments,
+        // avoids the ReadableStream + duplex:"half" workaround which silently
+        // fails on some storage backends.
+        const fileBuffer = fs.readFileSync(zipPath);
+        const uploadRes = await fetch(uploadData.signedUrl, {
+            method: "PUT",
+            headers: {
+                "Content-Type": "application/zip",
+                "Content-Length": String(zipSize),
+            },
+            body: fileBuffer,
+        });
+        if (!uploadRes.ok) {
+            uploadSpinner.fail(stepLabel(4, 5, "Upload failed"));
+            const errText = await uploadRes.text();
+            throw new Error(`Storage upload failed: ${errText}`);
+        }
+        uploadSpinner.succeed(stepLabel(4, 5, "Uploaded"));
+        // ── Step 5: Finalize ────────────────────────────────────
+        const finalizeSpinner = ora(stepLabel(5, 5, "Finalizing release...")).start();
+        const release = await apiRequest("/codepush/release", {
+            method: "POST",
+            body: JSON.stringify({
+                app_id: opts.app,
+                deployment: opts.deployment,
+                platform,
+                target_binary_range: opts.targetVersion,
+                description: opts.description || "",
+                is_mandatory: opts.mandatory,
+                bundle_url: uploadData.publicUrl,
+                bundle_hash: bundleHash,
+                package_size: zipSize,
+                scheduled_at: opts.scheduledAt,
+                rollout_pct: rolloutPct,
+            }),
+        });
+        finalizeSpinner.succeed(stepLabel(5, 5, "Release created"));
+        printSummary("React Native release published", [
+            ["Platform", platform],
+            ["Deployment", opts.deployment],
+            ["Target", opts.targetVersion],
+            ["Mandatory", opts.mandatory ? chalk.yellow("yes") : "no"],
+            ["Rollout", `${rolloutPct}%`],
+            ["Size", `${(zipSize / 1024).toFixed(1)} KB`],
+            ["Hash", bundleHash.slice(0, 16) + "…"],
+            ["Release ID", String(release.id)],
+        ]);
+        // ── Cleanup ─────────────────────────────────────────────
+        fs.rmSync(buildDir, { recursive: true, force: true });
+        if (fs.existsSync(zipPath))
+            fs.unlinkSync(zipPath);
+    }
+    catch (err) {
+        if (fs.existsSync(buildDir))
+            fs.rmSync(buildDir, { recursive: true, force: true });
+        if (fs.existsSync(zipPath))
+            fs.unlinkSync(zipPath);
+        console.error(chalk.red(`\n  ✗ ${err.message}`));
+        process.exit(1);
+    }
+});

package/dist/commands/release.d.ts

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

package/dist/commands/release.js

@@ -0,0 +1,106 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import fs from "fs";
+import path from "path";
+import { apiRequest } from "../api.js";
+import { stepLabel, printSummary } from "../utils/ui.js";
+import { requireValidPlatform, requireValidDeployment, requireValidVersion, requireNonEmpty, requireValidRollout } from "../utils/validators.js";
+export const releaseCommand = new Command("release")
+    .description("Upload a JS bundle and create an OTA release")
+    .requiredOption("-a, --app <appIdOrName>", "App ID or Name")
+    .requiredOption("-d, --deployment <name>", "Deployment name (e.g. Staging, Production)")
+    .requiredOption("-p, --platform <os>", "Target platform (android | ios)")
+    .requiredOption("-f, --file <path>", "Path to the bundle file (.bundle or .zip)")
+    .requiredOption("-t, --target-version <version>", "Target app binary version or semver range (e.g. ^1.0.0)")
+    .option("--description <text>", "Release description")
+    .option("--mandatory", "Mark update as mandatory", false)
+    .option("--scheduled-at <datetime>", "Schedule the release (ISO 8601)")
+    .option("--rollout <percentage>", "Rollout percentage (0-100)", "100")
+    .addHelpText("after", `
+Examples:
+  $ appspacer release -a my-app -d Staging -p android -f ./bundle.zip -t 1.0.0
+  $ appspacer release -a my-app -d Production -p ios -f ./main.jsbundle -t ^2.0.0 --mandatory`)
+    .action(async (opts) => {
+    // ── Validate inputs ─────────────────────────────────────
+    requireValidPlatform(opts.platform);
+    requireNonEmpty(opts.app, "App ID");
+    requireValidDeployment(opts.deployment);
+    requireValidVersion(opts.targetVersion);
+    const rolloutPct = requireValidRollout(opts.rollout);
+    try {
+        const filePath = path.resolve(opts.file);
+        if (!fs.existsSync(filePath)) {
+            console.error(chalk.red(`  ✗ File not found: ${filePath}`));
+            process.exit(1);
+        }
+        const filename = path.basename(filePath);
+        const fileSize = fs.statSync(filePath).size;
+        // ── Step 1: Get upload URL ──────────────────────────────
+        const urlSpinner = ora(stepLabel(1, 3, "Requesting upload URL...")).start();
+        let uploadData;
+        try {
+            uploadData = await apiRequest("/codepush/upload-url", {
+                method: "POST",
+                body: JSON.stringify({ app_id: opts.app, deployment: opts.deployment, filename }),
+            });
+            urlSpinner.succeed(stepLabel(1, 3, "Upload URL ready"));
+        }
+        catch (err) {
+            urlSpinner.fail(stepLabel(1, 3, "Failed to get upload URL"));
+            throw err;
+        }
+        // ── Step 2: Upload ──────────────────────────────────────
+        const uploadSpinner = ora(stepLabel(2, 3, `Uploading ${filename} (${(fileSize / 1024).toFixed(1)} KB)...`)).start();
+        // Read file into buffer — reliable across all Node 18+ environments,
+        // avoids the ReadableStream + duplex:"half" workaround.
+        const fileBuffer = fs.readFileSync(filePath);
+        const contentType = filename.endsWith(".zip") ? "application/zip" : "application/octet-stream";
+        const uploadRes = await fetch(uploadData.signedUrl, {
+            method: "PUT",
+            headers: {
+                "Content-Type": contentType,
+                "Content-Length": String(fileSize),
+            },
+            body: fileBuffer,
+        });
+        if (!uploadRes.ok) {
+            uploadSpinner.fail(stepLabel(2, 3, "Upload failed"));
+            const errText = await uploadRes.text();
+            throw new Error(`Upload failed: ${errText}`);
+        }
+        uploadSpinner.succeed(stepLabel(2, 3, "Uploaded"));
+        // ── Step 3: Create release ──────────────────────────────
+        const releaseSpinner = ora(stepLabel(3, 3, "Creating release...")).start();
+        const release = await apiRequest("/codepush/release", {
+            method: "POST",
+            body: JSON.stringify({
+                app_id: opts.app,
+                deployment: opts.deployment,
+                platform: opts.platform,
+                target_binary_range: opts.targetVersion,
+                description: opts.description || "",
+                is_mandatory: opts.mandatory,
+                bundle_url: uploadData.publicUrl,
+                package_size: fileSize,
+                scheduled_at: opts.scheduledAt,
+                rollout_pct: rolloutPct,
+            }),
+        });
+        releaseSpinner.succeed(stepLabel(3, 3, "Release created"));
+        printSummary("Release published", [
+            ["Platform", opts.platform],
+            ["Deployment", opts.deployment],
+            ["Target", opts.targetVersion],
+            ["Mandatory", opts.mandatory ? chalk.yellow("yes") : "no"],
+            ["Rollout", `${rolloutPct}%`],
+            ["File", filename],
+            ["Size", `${(fileSize / 1024).toFixed(1)} KB`],
+            ["Release ID", String(release.id)],
+        ]);
+    }
+    catch (err) {
+        console.error(chalk.red(`\n  ✗ ${err.message}`));
+        process.exit(1);
+    }
+});

package/dist/commands/rollback.d.ts

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

package/dist/commands/rollback.js

@@ -0,0 +1,43 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { apiRequest } from "../api.js";
+import { requireValidPlatform, requireValidDeployment, requireNonEmpty } from "../utils/validators.js";
+export const rollbackCommand = new Command("rollback")
+    .description("Roll back the latest release for a deployment")
+    .requiredOption("-a, --app <appIdOrName>", "App ID or Name")
+    .requiredOption("-d, --deployment <name>", "Deployment name (e.g. Staging, Production)")
+    .requiredOption("-p, --platform <os>", "Target platform (android | ios)")
+    .addHelpText("after", `
+Examples:
+  $ appspacer rollback -a my-app -d Staging -p android
+  $ appspacer rollback -a my-app -d Production -p ios`)
+    .action(async (opts) => {
+    // ── Validate inputs ─────────────────────────────────────
+    requireNonEmpty(opts.app, "App ID");
+    requireValidDeployment(opts.deployment);
+    requireValidPlatform(opts.platform);
+    try {
+        console.log(chalk.dim(`  → Rolling back ${opts.platform} release on ${opts.deployment}...`));
+        const response = await apiRequest("/codepush/rollback", {
+            method: "POST",
+            body: JSON.stringify({
+                app_id: opts.app,
+                deployment: opts.deployment,
+                platform: opts.platform,
+            }),
+        });
+        console.log(chalk.green(`\n  ✓ Rollback successful!`));
+        console.log(chalk.dim(`    Disabled:    ${response.disabled_release.label} (v${response.disabled_release.version})`));
+        if (response.now_active_release) {
+            console.log(chalk.dim(`    Now active:  ${response.now_active_release.label} (v${response.now_active_release.version})`));
+        }
+        else {
+            console.log(chalk.yellow(`    Warning: no active releases remaining for this deployment.`));
+        }
+        console.log("");
+    }
+    catch (err) {
+        console.error(chalk.red(`  ✗ ${err.message}`));
+        process.exit(1);
+    }
+});

package/dist/commands/setup.d.ts

@@ -0,0 +1,22 @@
+import { Command } from "commander";
+type Architecture = "new" | "traditional";
+export declare function detectArchitecture(content: string): Architecture;
+export declare function hasExistingInjection(content: string): boolean;
+export declare function removeExistingInjection(content: string): string;
+export declare function injectTraditionalAndroid(content: string): {
+    result: string;
+    method: string;
+    warn?: string;
+};
+export declare function injectNewArchAndroid(content: string): {
+    result: string;
+    method: string;
+    warn?: string;
+};
+export declare function injectIosSetup(content: string, filePath: string): {
+    result: string;
+    warn?: string;
+};
+export declare const undoCommand: Command;
+export declare const setupCommand: Command;
+export {};