mobile-app-builder 0.0.1

package/dist/utils/dependencies.js

@@ -0,0 +1,388 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureGit = ensureGit;
+exports.ensureNode = ensureNode;
+exports.ensureGitHubCLI = ensureGitHubCLI;
+exports.ensureJava = ensureJava;
+exports.ensureAndroidSdk = ensureAndroidSdk;
+exports.detectProjectType = detectProjectType;
+exports.ensureProjectType = ensureProjectType;
+const chalk_1 = __importDefault(require("chalk"));
+const execa_1 = require("execa");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const isWin = process.platform === "win32";
+async function ensureGit() {
+    try {
+        await (0, execa_1.execa)("git", ["--version"]);
+        console.log(chalk_1.default.green("Git is installed."));
+    }
+    catch {
+        console.log(chalk_1.default.yellow("\nGit is missing. Attempting to install via winget..."));
+        if (isWin) {
+            try {
+                await (0, execa_1.execa)("winget", [
+                    "install",
+                    "--id",
+                    "Git.Git",
+                    "-e",
+                    "--source",
+                    "winget",
+                    "--accept-package-agreements",
+                    "--accept-source-agreements",
+                ], { stdio: "inherit" });
+                console.log(chalk_1.default.green("Git installed successfully! Please restart terminal if it is not in PATH."));
+            }
+            catch (err) {
+                console.error(chalk_1.default.red("Failed to install Git. Please install manually."));
+                process.exit(1);
+            }
+        }
+        else {
+            console.error(chalk_1.default.red("Git is required. Please install manually."));
+            process.exit(1);
+        }
+    }
+}
+async function ensureNode(minMajorVersion = 22) {
+    try {
+        const { stdout } = await (0, execa_1.execa)("node", ["--version"]);
+        const match = stdout.match(/^v?(\d+)\./);
+        if (match && parseInt(match[1]) >= minMajorVersion) {
+            console.log(chalk_1.default.green(`Node.js is installed (${stdout.trim()}, >= v${minMajorVersion}).`));
+        }
+        else {
+            console.log(chalk_1.default.yellow(`Installed Node.js (${stdout.trim()}) is outdated. Required >= v${minMajorVersion}.`));
+        }
+    }
+    catch {
+        console.log(chalk_1.default.yellow("\nNode.js is not installed."));
+    }
+}
+async function ensureGitHubCLI() {
+    try {
+        await (0, execa_1.execa)("gh", ["--version"]);
+        console.log(chalk_1.default.green("gh is installed."));
+    }
+    catch {
+        console.log(chalk_1.default.yellow("\ngh not found. Attempting to install via winget..."));
+        if (isWin) {
+            try {
+                await (0, execa_1.execa)("winget", [
+                    "install",
+                    "--id",
+                    "GitHub.cli",
+                    "-e",
+                    "--source",
+                    "winget",
+                    "--accept-package-agreements",
+                    "--accept-source-agreements",
+                ], { stdio: "inherit" });
+                console.log(chalk_1.default.green("GitHub CLI installed successfully!"));
+            }
+            catch (err) {
+                console.error(chalk_1.default.red("Failed to install GitHub CLI."));
+                process.exit(1);
+            }
+        }
+        else {
+            console.error(chalk_1.default.red("GitHub CLI required. Install manually."));
+            process.exit(1);
+        }
+    }
+}
+async function ensureJava() {
+    const getJavaVer = async (cmdPath) => {
+        try {
+            const { stdout, stderr } = await (0, execa_1.execa)(cmdPath, ["-version"], {
+                reject: false,
+            });
+            const out = stdout || stderr;
+            const match = out.match(/version "(?:1\.)?(\d+)/);
+            return match ? parseInt(match[1]) : 0;
+        }
+        catch {
+            return 0;
+        }
+    };
+    const findJdkFolder = async () => {
+        if (!isWin)
+            return null;
+        const searchBasePaths = [
+            "C:/Program Files/Microsoft",
+            "C:/Program Files/Eclipse Adoptium",
+            "C:/Program Files/Java",
+        ];
+        for (const base of searchBasePaths) {
+            if (await fs_extra_1.default.pathExists(base)) {
+                const dirs = await fs_extra_1.default.readdir(base);
+                const jdk21Dirs = dirs.filter((d) => d.startsWith("jdk-21"));
+                if (jdk21Dirs.length > 0) {
+                    jdk21Dirs.sort((a, b) => b.localeCompare(a));
+                    return path_1.default.join(base, jdk21Dirs[0]);
+                }
+            }
+        }
+        return null;
+    };
+    let javaPath = "";
+    if (process.env.JAVA_HOME &&
+        (await fs_extra_1.default.pathExists(path_1.default.join(process.env.JAVA_HOME, "bin/java.exe")))) {
+        javaPath = path_1.default.join(process.env.JAVA_HOME, "bin/java.exe");
+    }
+    else {
+        try {
+            const { stdout } = await (0, execa_1.execa)(isWin ? "where" : "which", ["java"]);
+            if (stdout) {
+                javaPath = stdout.split("\n")[0].trim();
+            }
+        }
+        catch { }
+    }
+    if (javaPath) {
+        const ver = await getJavaVer(javaPath);
+        if (ver === 21) {
+            console.log(chalk_1.default.green(`Java 21 is available at: ${javaPath}`));
+            return;
+        }
+        else {
+            console.log(chalk_1.default.yellow(`Existing Java version (${ver}) is incompatible (required: JDK 21).`));
+            javaPath = "";
+        }
+    }
+    let existingJdk = await findJdkFolder();
+    if (existingJdk) {
+        process.env.JAVA_HOME = existingJdk;
+        process.env.Path = `${path_1.default.join(existingJdk, "bin")}${path_1.default.delimiter}${process.env.Path || ""}`;
+        console.log(chalk_1.default.green(`Located JDK 21 at: ${existingJdk}`));
+        return;
+    }
+    console.log(chalk_1.default.yellow("\nJDK 21 not found. Attempting to install Microsoft OpenJDK 21 via winget..."));
+    if (isWin) {
+        try {
+            await (0, execa_1.execa)("winget", [
+                "install",
+                "--id",
+                "Microsoft.OpenJDK.21",
+                "-e",
+                "--source",
+                "winget",
+                "--accept-package-agreements",
+                "--accept-source-agreements",
+            ], { stdio: "inherit" });
+            existingJdk = await findJdkFolder();
+            if (existingJdk) {
+                process.env.JAVA_HOME = existingJdk;
+                process.env.Path = `${path_1.default.join(existingJdk, "bin")}${path_1.default.delimiter}${process.env.Path || ""}`;
+                console.log(chalk_1.default.green(`[SUCCESS] Set JAVA_HOME to ${existingJdk} and updated PATH`));
+                return;
+            }
+        }
+        catch {
+            console.error(chalk_1.default.red("Failed to install JDK 21."));
+        }
+    }
+    else {
+        console.error(chalk_1.default.red("Please install Java (JDK 21) manually and re-run."));
+        process.exit(1);
+    }
+    if (!(await findJdkFolder())) {
+        console.error(chalk_1.default.red("[ERROR] Could not install or locate JDK 21. Please install Java 21 manually."));
+        process.exit(1);
+    }
+}
+async function ensureAndroidSdk() {
+    const candidatePaths = [
+        process.env.ANDROID_HOME,
+        process.env.ANDROID_SDK_ROOT,
+        "C:/Android",
+        path_1.default.join(os_1.default.homedir(), "AppData/Local/Android/Sdk"),
+    ].filter(Boolean);
+    let validSdk = null;
+    for (const p of candidatePaths) {
+        if ((await fs_extra_1.default.pathExists(path_1.default.join(p, "platform-tools"))) ||
+            (await fs_extra_1.default.pathExists(path_1.default.join(p, "build-tools")))) {
+            validSdk = p.replace(/\\/g, "/");
+            break;
+        }
+    }
+    if (validSdk) {
+        console.log(chalk_1.default.green(`Android SDK Found at ${validSdk}`));
+        process.env.ANDROID_HOME = validSdk;
+        process.env.ANDROID_SDK_ROOT = validSdk;
+        const tools = [
+            path_1.default.join(validSdk, "platform-tools"),
+            path_1.default.join(validSdk, "cmdline-tools", "latest", "bin"),
+            path_1.default.join(validSdk, "emulator"),
+        ];
+        process.env.Path = `${tools.join(path_1.default.delimiter)}${path_1.default.delimiter}${process.env.Path || ""}`;
+        return validSdk;
+    }
+    console.log(chalk_1.default.yellow("\nNo Android SDK found on disk. Installing standalone command line tools to C:/Android..."));
+    validSdk = "C:/Android";
+    await fs_extra_1.default.ensureDir(validSdk);
+    const cmdlineToolsDir = path_1.default.join(validSdk, "cmdline-tools", "latest");
+    if (!(await fs_extra_1.default.pathExists(path_1.default.join(cmdlineToolsDir, "bin", "sdkmanager.bat")))) {
+        console.log(chalk_1.default.cyan("-> Downloading official Google Android Command Line Tools..."));
+        let zipName = "commandlinetools-win-11479570_latest.zip";
+        try {
+            const res = await fetch("https://dl.google.com/android/repository/repository2-3.xml");
+            const text = await res.text();
+            const matches = text.match(/commandlinetools-win-(\d+)_latest\.zip/g);
+            if (matches && matches.length > 0) {
+                matches.sort((a, b) => parseInt(b.match(/\d+/)[0]) - parseInt(a.match(/\d+/)[0]));
+                zipName = matches[0];
+            }
+        }
+        catch { }
+        const zipUrl = `https://dl.google.com/android/repository/${zipName}`;
+        const rand = Math.floor(Math.random() * 100000);
+        const zipPath = path_1.default.join(os_1.default.tmpdir(), `cmdline-tools-${rand}.zip`);
+        console.log(chalk_1.default.cyan(`-> Downloading ${zipName} (~130MB)...`));
+        const res = await fetch(zipUrl);
+        if (!res.ok)
+            throw new Error(`Failed to download SDK: ${res.statusText}`);
+        const buffer = await res.arrayBuffer();
+        await fs_extra_1.default.writeFile(zipPath, Buffer.from(buffer));
+        console.log(chalk_1.default.green("[SUCCESS] Download complete."));
+        console.log(chalk_1.default.cyan("-> Extracting SDK tools archive..."));
+        const extractTemp = path_1.default.join(os_1.default.tmpdir(), `android-sdk-temp-${rand}`);
+        await fs_extra_1.default.remove(extractTemp);
+        await (0, execa_1.execa)("powershell", [
+            "-Command",
+            `Expand-Archive -Path '${zipPath}' -DestinationPath '${extractTemp}' -Force`,
+        ]);
+        await fs_extra_1.default.ensureDir(path_1.default.join(validSdk, "cmdline-tools"));
+        if (await fs_extra_1.default.pathExists(path_1.default.join(extractTemp, "cmdline-tools"))) {
+            await fs_extra_1.default.move(path_1.default.join(extractTemp, "cmdline-tools"), cmdlineToolsDir, {
+                overwrite: true,
+            });
+        }
+        await fs_extra_1.default.remove(zipPath);
+        await fs_extra_1.default.remove(extractTemp);
+        console.log(chalk_1.default.green("[SUCCESS] Extraction complete."));
+    }
+    const sdkManager = path_1.default.join(validSdk, "cmdline-tools", "latest", "bin", "sdkmanager.bat");
+    if (await fs_extra_1.default.pathExists(sdkManager)) {
+        console.log(chalk_1.default.cyan("-> Running sdkmanager to install: platform-tools, build-tools;34.0.0, platforms;android-34..."));
+        const licenseAccept = Array(10).fill("y").join("\n") + "\n";
+        try {
+            const packages = [
+                "platform-tools",
+                "build-tools;34.0.0",
+                "platforms;android-34",
+            ];
+            const sdkProcess = (0, execa_1.execa)("cmd.exe", [
+                "/c",
+                `${sdkManager} --sdk_root="${validSdk}" ${packages.join(" ")}`,
+            ]);
+            if (sdkProcess.stdin) {
+                sdkProcess.stdin.write(licenseAccept);
+                sdkProcess.stdin.end();
+            }
+            await sdkProcess;
+            const licenseProcess = (0, execa_1.execa)("cmd.exe", [
+                "/c",
+                `${sdkManager} --licenses --sdk_root="${validSdk}"`,
+            ]);
+            if (licenseProcess.stdin) {
+                licenseProcess.stdin.write(licenseAccept);
+                licenseProcess.stdin.end();
+            }
+            await licenseProcess;
+            console.log(chalk_1.default.green("[SUCCESS] SDK packages and licenses accepted successfully."));
+        }
+        catch (e) {
+            console.log(chalk_1.default.yellow(`[WARNING] sdkmanager encountered an issue: ${e.message}`));
+        }
+    }
+    process.env.ANDROID_HOME = validSdk;
+    process.env.ANDROID_SDK_ROOT = validSdk;
+    const tools = [
+        path_1.default.join(validSdk, "platform-tools"),
+        path_1.default.join(validSdk, "cmdline-tools", "latest", "bin"),
+        path_1.default.join(validSdk, "emulator"),
+    ];
+    process.env.Path = `${tools.join(path_1.default.delimiter)}${path_1.default.delimiter}${process.env.Path || ""}`;
+    return validSdk;
+}
+async function detectProjectType() {
+    const cwd = process.cwd();
+    const pkgPath = path_1.default.join(cwd, "package.json");
+    const appJsonPath = path_1.default.join(cwd, "app.json");
+    const appConfigTs = path_1.default.join(cwd, "app.config.ts");
+    const appConfigJs = path_1.default.join(cwd, "app.config.js");
+    const androidDir = path_1.default.join(cwd, "android");
+    const hasAndroidDir = await fs_extra_1.default.pathExists(androidDir);
+    let hasExpoDep = false;
+    let hasRNDep = false;
+    if (await fs_extra_1.default.pathExists(pkgPath)) {
+        try {
+            const pkg = await fs_extra_1.default.readJson(pkgPath);
+            hasExpoDep = Boolean(pkg.dependencies?.expo || pkg.devDependencies?.expo);
+            hasRNDep = Boolean(pkg.dependencies?.["react-native"] ||
+                pkg.devDependencies?.["react-native"]);
+        }
+        catch { }
+    }
+    let hasExpoAppJson = false;
+    if (await fs_extra_1.default.pathExists(appJsonPath)) {
+        try {
+            const appJson = await fs_extra_1.default.readJson(appJsonPath);
+            hasExpoAppJson = Boolean(appJson.expo);
+        }
+        catch { }
+    }
+    const hasExpoAppConfig = (await fs_extra_1.default.pathExists(appConfigTs)) || (await fs_extra_1.default.pathExists(appConfigJs));
+    const isExpo = hasExpoDep || hasExpoAppJson || hasExpoAppConfig;
+    if (isExpo) {
+        // Check if android folder is gitignored (managed workflow indicator)
+        let isGitIgnored = false;
+        const gitignorePath = path_1.default.join(cwd, ".gitignore");
+        if (await fs_extra_1.default.pathExists(gitignorePath)) {
+            try {
+                const gitignore = await fs_extra_1.default.readFile(gitignorePath, "utf8");
+                isGitIgnored = /^\s*\/?android\/?\s*$/m.test(gitignore);
+            }
+            catch { }
+        }
+        // If android folder does not exist or is gitignored, it is managed Expo
+        const isManaged = !hasAndroidDir || isGitIgnored;
+        return {
+            type: "expo",
+            isManaged,
+            hasAndroidDir,
+        };
+    }
+    if (hasRNDep || hasAndroidDir) {
+        const hasAndroidGradle = (await fs_extra_1.default.pathExists(path_1.default.join(androidDir, "build.gradle"))) ||
+            (await fs_extra_1.default.pathExists(path_1.default.join(androidDir, "app", "build.gradle")));
+        if (hasRNDep || hasAndroidGradle) {
+            return {
+                type: "react-native",
+                isManaged: false,
+                hasAndroidDir,
+            };
+        }
+    }
+    return null;
+}
+async function ensureProjectType() {
+    const info = await detectProjectType();
+    if (!info) {
+        console.error(chalk_1.default.red("Not inside an Expo or React Native project!"));
+        console.error(chalk_1.default.yellow("Please run this command from the root of an Expo or React Native project."));
+        process.exit(1);
+    }
+    if (info.type === "expo") {
+        console.log(chalk_1.default.green(`Project type: Expo (${info.isManaged ? "Managed" : "Bare"} workflow).`));
+    }
+    else {
+        console.log(chalk_1.default.green("Project type: React Native (Native CLI)."));
+    }
+    return info;
+}

package/dist/utils/github.d.ts

@@ -0,0 +1,5 @@
+export declare function generatePublishWorkflow(appPackageName: string): Promise<void>;
+export declare function hasGitRemote(): Promise<boolean>;
+export declare function isGhAuthenticated(): Promise<boolean>;
+export declare function publishGitHubRelease(tag: string, assetPath: string, title: string, notes: string, profileName: string, prerelease?: boolean): Promise<boolean>;
+export declare function triggerGitHubWorkflow(tag: string, track: string): Promise<void>;

package/dist/utils/github.js

@@ -0,0 +1,216 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePublishWorkflow = generatePublishWorkflow;
+exports.hasGitRemote = hasGitRemote;
+exports.isGhAuthenticated = isGhAuthenticated;
+exports.publishGitHubRelease = publishGitHubRelease;
+exports.triggerGitHubWorkflow = triggerGitHubWorkflow;
+const chalk_1 = __importDefault(require("chalk"));
+const execa_1 = require("execa");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+async function generatePublishWorkflow(appPackageName) {
+    console.log(chalk_1.default.cyan("Validating / Generating GitHub Actions deployment workflow..."));
+    const workflowDir = path_1.default.join(process.cwd(), ".github", "workflows");
+    const workflowPath = path_1.default.join(workflowDir, "publish.yml");
+    await fs_extra_1.default.ensureDir(workflowDir);
+    const expectedWorkflowContent = `name: Deploy Release to Play Store
+
+on:
+  workflow_dispatch:
+    inputs:
+      tag_name:
+        description: "Release Tag Name (e.g. v1.0.0)"
+        required: true
+        type: string
+      track:
+        description: "Play Store Track"
+        required: false
+        type: choice
+        options:
+          - internal
+          - alpha
+          - beta
+          - production
+        default: "alpha"
+
+jobs:
+  deploy:
+    name: Publish AAB to Play Store
+    runs-on: ubuntu-latest
+    steps:
+      - name: 📥 Checkout repository
+        uses: actions/checkout@v6
+
+      - name: 📥 Download AAB from GitHub Release
+        env:
+          GH_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+        run: |
+          TAG="\${{ inputs.tag_name }}"
+          echo "Downloading assets for release tag: $TAG"
+          mkdir -p release-artifacts
+          gh release download "$TAG" --pattern "*.aab" --dir release-artifacts
+          ls -la release-artifacts
+
+      - name: 📝 Prepare Release Notes
+        env:
+          GH_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+        run: |
+          mkdir -p whatsnew
+          NOTES="$(gh release view "\${{ inputs.tag_name }}" --json body -q .body 2>/dev/null || echo "")"
+          if [ -z "$NOTES" ] || [ "$NOTES" == "null" ]; then
+            NOTES="We are constantly working to improve your experience. This update includes performance improvements, bug fixes, and enhancements to keep the app running smoothly."
+          fi
+          # Play Store max 500 chars; truncate if needed
+          NOTES=$(echo -e "$NOTES" | head -c 500)
+          echo "$NOTES" > whatsnew/whatsnew-en-US
+          echo "--- Release Notes ---"
+          cat whatsnew/whatsnew-en-US
+
+      - name: 📱 Upload to Google Play
+        uses: r0adkll/upload-google-play@v1
+        with:
+          serviceAccountJsonPlainText: \${{ secrets.PLAY_SERVICE_ACCOUNT }}
+          packageName: ${appPackageName}
+          releaseFiles: release-artifacts/*.aab
+          tracks: \${{ inputs.track || 'alpha' }}
+          status: completed
+          whatsNewDirectory: whatsnew
+`;
+    let writeWorkflow = false;
+    if (!(await fs_extra_1.default.pathExists(workflowPath))) {
+        console.log(chalk_1.default.yellow(`GitHub Action workflow missing! Generating ${workflowPath}...`));
+        writeWorkflow = true;
+    }
+    else {
+        const existingWorkflow = await fs_extra_1.default.readFile(workflowPath, "utf8");
+        if (!existingWorkflow.includes(`packageName: ${appPackageName}`)) {
+            console.log(chalk_1.default.yellow(`Warning: ${workflowPath} has incorrect packageName! Auto-correcting...`));
+            writeWorkflow = true;
+        }
+        else if (!existingWorkflow.includes("r0adkll/upload-google-play@v1")) {
+            console.log(chalk_1.default.yellow(`Warning: ${workflowPath} does not use standard upload action! Updating...`));
+            writeWorkflow = true;
+        }
+    }
+    if (writeWorkflow) {
+        await fs_extra_1.default.writeFile(workflowPath, expectedWorkflowContent);
+        console.log(chalk_1.default.green(`Verified and updated GitHub Actions deployment workflow.`));
+    }
+    else {
+        console.log(chalk_1.default.green(`GitHub Action workflow exists and is validated.`));
+    }
+}
+async function hasGitRemote() {
+    try {
+        const { stdout } = await (0, execa_1.execa)("git", ["remote"]);
+        return stdout.trim().length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+async function isGhAuthenticated() {
+    try {
+        const { stdout, stderr } = await (0, execa_1.execa)("gh", ["auth", "status"], {
+            reject: false,
+        });
+        const out = (stdout || "") + (stderr || "");
+        return (out.includes("Logged in to") ||
+            out.includes("Active account: true") ||
+            out.includes("account"));
+    }
+    catch {
+        return false;
+    }
+}
+async function publishGitHubRelease(tag, assetPath, title, notes, profileName, prerelease = false) {
+    console.log(chalk_1.default.cyan(`\nStep 09: Publishing build artifact to GitHub Releases (${tag})${prerelease ? " [pre-release]" : ""}...`));
+    const hasRemote = await hasGitRemote();
+    if (!hasRemote) {
+        console.log(chalk_1.default.yellow("Note: No git remote found. Skipping GitHub Release publication."));
+        console.log(chalk_1.default.gray("To enable automated releases, connect this repository to GitHub ('git remote add origin <url>')."));
+        return false;
+    }
+    const isAuth = await isGhAuthenticated();
+    if (!isAuth) {
+        console.log(chalk_1.default.yellow("Note: GitHub CLI is not logged in. Run 'gh auth login' to enable automated releases. Skipping release publication."));
+        return false;
+    }
+    try {
+        console.log(chalk_1.default.gray(`Committing changes and pushing...`));
+        try {
+            await (0, execa_1.execa)("git", ["add", "."]);
+        }
+        catch { }
+        try {
+            await (0, execa_1.execa)("git", [
+                "commit",
+                "-m",
+                `chore: release ${tag} (${profileName})`,
+            ]);
+        }
+        catch { }
+        try {
+            await (0, execa_1.execa)("git", ["push"]);
+        }
+        catch (err) {
+            console.log(chalk_1.default.gray(`Note: git push skipped (${err.message ? err.message.split("\n")[0] : "no upstream"}).`));
+        }
+        let releaseExists = false;
+        try {
+            await (0, execa_1.execa)("gh", ["release", "view", tag]);
+            releaseExists = true;
+        }
+        catch { }
+        if (releaseExists) {
+            console.log(chalk_1.default.yellow(`Release ${tag} already exists. Updating and uploading asset...`));
+            await (0, execa_1.execa)("gh", ["release", "upload", tag, assetPath, "--clobber"], {
+                stdio: "inherit",
+            });
+        }
+        else {
+            console.log(chalk_1.default.yellow(`Preparing GitHub Release ${tag}${prerelease ? " (pre-release)" : ""}...`));
+            const createArgs = [
+                "release",
+                "create",
+                tag,
+                assetPath,
+                `--title=${title}`,
+                `--notes=${notes}`,
+            ];
+            if (prerelease) {
+                createArgs.push("--prerelease");
+            }
+            await (0, execa_1.execa)("gh", createArgs, { stdio: "inherit" });
+        }
+        console.log(chalk_1.default.green(`Successfully published ${tag} to GitHub Releases!`));
+        return true;
+    }
+    catch (err) {
+        console.log(chalk_1.default.yellow(`Warning: Failed to publish to GitHub Releases: ${err.stderr || err.message}`));
+        console.log(chalk_1.default.yellow("Your build completed successfully and the artifact is saved locally."));
+        return false;
+    }
+}
+async function triggerGitHubWorkflow(tag, track) {
+    console.log(chalk_1.default.cyan(`\nTriggering Play Store deployment workflow for track '${track}'...`));
+    try {
+        await (0, execa_1.execa)("gh", [
+            "workflow",
+            "run",
+            "publish.yml",
+            "-f",
+            `tag_name=${tag}`,
+            "-f",
+            `track=${track}`,
+        ]);
+        console.log(chalk_1.default.green("Play Store deployment triggered successfully! Check GitHub Actions tab for progress."));
+    }
+    catch {
+        console.log(chalk_1.default.yellow("Note: Could not automatically trigger 'publish.yml'."));
+    }
+}

package/dist/utils/gradle.d.ts

@@ -0,0 +1,4 @@
+export declare function patchGradleProperties(): Promise<void>;
+export declare function getGradleVersionCode(): Promise<number>;
+export declare function syncBuildGradle(appVersion: string, versionCode: number): Promise<void>;
+export declare function runGradleBuild(assembleTask: string): Promise<void>;