mobile-app-builder 0.0.1

package/dist/utils/gradle.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchGradleProperties = patchGradleProperties;
+exports.getGradleVersionCode = getGradleVersionCode;
+exports.syncBuildGradle = syncBuildGradle;
+exports.runGradleBuild = runGradleBuild;
+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 patchGradleProperties() {
+    console.log(chalk_1.default.cyan("Patching gradle.properties for memory limit..."));
+    const propsPath = path_1.default.join(process.cwd(), "android", "gradle.properties");
+    if (await fs_extra_1.default.pathExists(propsPath)) {
+        let props = await fs_extra_1.default.readFile(propsPath, "utf8");
+        props = props.replace(/^org.gradle.jvmargs=.*?$/m, "org.gradle.jvmargs=-Xmx4096m -XX:MaxMetaspaceSize=1024m -XX:+UseG1GC -Dfile.encoding=UTF-8");
+        if (!props.includes("org.gradle.caching")) {
+            props +=
+                "\norg.gradle.caching=true\norg.gradle.configureondemand=true\norg.gradle.parallel=true\norg.gradle.daemon=true\nkotlin.incremental=true";
+        }
+        await fs_extra_1.default.writeFile(propsPath, props);
+    }
+}
+async function getGradleVersionCode() {
+    const gradlePath = path_1.default.join(process.cwd(), "android", "app", "build.gradle");
+    if (await fs_extra_1.default.pathExists(gradlePath)) {
+        try {
+            const content = await fs_extra_1.default.readFile(gradlePath, "utf8");
+            const match = content.match(/versionCode\s*=?\s*(\d+)/);
+            if (match && match[1]) {
+                return parseInt(match[1], 10);
+            }
+        }
+        catch { }
+    }
+    return 1;
+}
+async function syncBuildGradle(appVersion, versionCode) {
+    const gradlePath = path_1.default.join(process.cwd(), "android", "app", "build.gradle");
+    if (await fs_extra_1.default.pathExists(gradlePath)) {
+        let content = await fs_extra_1.default.readFile(gradlePath, "utf8");
+        content = content.replace(/versionName\s*=?\s*".*?"/, `versionName "${appVersion}"`);
+        if (versionCode > 0) {
+            content = content.replace(/versionCode\s*=?\s*\d+/, `versionCode ${versionCode}`);
+        }
+        content = content.replace(/(\brelease\s*\{[\s\S]*?)(signingConfig\s+signingConfigs\.debug)/, "$1signingConfig null");
+        await fs_extra_1.default.writeFile(gradlePath, content);
+    }
+}
+async function runGradleBuild(assembleTask) {
+    const isWin = process.platform === "win32";
+    const cmd = isWin ? ".\\gradlew.bat" : "./gradlew";
+    if (!isWin) {
+        try {
+            await (0, execa_1.execa)("chmod", ["+x", "gradlew"], { cwd: "android" });
+        }
+        catch { }
+    }
+    console.log(chalk_1.default.cyan(`Building (${assembleTask})...`));
+    try {
+        await (0, execa_1.execa)(cmd, [
+            assembleTask,
+            "--build-cache",
+            "--configure-on-demand",
+            "--parallel",
+            "--quiet",
+        ], { cwd: "android", stdio: "inherit" });
+    }
+    catch (err) {
+        console.error(chalk_1.default.red("Error: Gradle build failed."));
+        throw err;
+    }
+}

package/dist/utils/project.d.ts

@@ -0,0 +1,22 @@
+export declare function bumpVersion(): Promise<void>;
+export declare function syncAppJsonVersion(): Promise<void>;
+/**
+ * Unified project version synchronizer
+ */
+export declare function syncProjectVersionConfig(shouldBump: boolean, projectType: "expo" | "react-native"): Promise<void>;
+/**
+ * Converts a package name or raw slug into a proper, human-readable display name.
+ * e.g., "@scope/my-awesome-app" -> "My Awesome App"
+ *       "mobile-app-builder" -> "Mobile App Builder"
+ *       "my_cool_app" -> "My Cool App"
+ *       "myApp" -> "My App"
+ */
+export declare function toProperName(name?: string): string;
+/**
+ * Extracts app display name from native strings.xml or package.json
+ */
+export declare function getNativeAppName(): Promise<string>;
+/**
+ * Extracts package name / applicationId from Gradle or AndroidManifest
+ */
+export declare function getNativePackageName(): Promise<string | null>;

package/dist/utils/project.js

@@ -0,0 +1,143 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bumpVersion = bumpVersion;
+exports.syncAppJsonVersion = syncAppJsonVersion;
+exports.syncProjectVersionConfig = syncProjectVersionConfig;
+exports.toProperName = toProperName;
+exports.getNativeAppName = getNativeAppName;
+exports.getNativePackageName = getNativePackageName;
+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 bumpVersion() {
+    console.log(chalk_1.default.cyan("Bumping app version string..."));
+    try {
+        await (0, execa_1.execa)("npm", ["version", "patch", "--no-git-tag-version"]);
+        console.log(chalk_1.default.green("Successfully bumped package version."));
+    }
+    catch (err) {
+        console.log(chalk_1.default.yellow("Warning: Failed to bump version via npm."));
+    }
+}
+async function syncAppJsonVersion() {
+    const appJsonPath = path_1.default.join(process.cwd(), "app.json");
+    const pkgPath = path_1.default.join(process.cwd(), "package.json");
+    if ((await fs_extra_1.default.pathExists(appJsonPath)) && (await fs_extra_1.default.pathExists(pkgPath))) {
+        try {
+            const pkg = await fs_extra_1.default.readJson(pkgPath);
+            const appJson = await fs_extra_1.default.readJson(appJsonPath);
+            if (appJson.expo && appJson.expo.version !== pkg.version) {
+                appJson.expo.version = pkg.version;
+                await fs_extra_1.default.writeJson(appJsonPath, appJson, { spaces: 2 });
+                console.log(chalk_1.default.green(`Synced app.json version to ${pkg.version}.`));
+            }
+        }
+        catch { }
+    }
+}
+/**
+ * Unified project version synchronizer
+ */
+async function syncProjectVersionConfig(shouldBump, projectType) {
+    if (shouldBump) {
+        console.log(chalk_1.default.cyan("\nStep 02: Bumping app version in package.json..."));
+        await bumpVersion();
+    }
+    else {
+        console.log(chalk_1.default.gray("\nStep 02: Preserving existing app version in package.json..."));
+    }
+    if (projectType === "expo") {
+        await syncAppJsonVersion();
+    }
+}
+/**
+ * Converts a package name or raw slug into a proper, human-readable display name.
+ * e.g., "@scope/my-awesome-app" -> "My Awesome App"
+ *       "mobile-app-builder" -> "Mobile App Builder"
+ *       "my_cool_app" -> "My Cool App"
+ *       "myApp" -> "My App"
+ */
+function toProperName(name) {
+    if (!name || typeof name !== "string")
+        return "App";
+    // Remove npm scope if present: @scope/my-app -> my-app
+    let cleaned = name.replace(/^@[^/]+\//, "");
+    // Insert space between lower/number and upper case in camelCase (e.g. "myApp" -> "my App")
+    cleaned = cleaned.replace(/([a-z0-9])([A-Z])/g, (_m, p1, p2) => `${p1} ${p2}`);
+    // Replace delimiters (hyphens, underscores, dots, slashes) with spaces
+    cleaned = cleaned.replace(/[-_./]+/g, " ");
+    // Remove any characters that could disrupt dname format or names
+    cleaned = cleaned.replace(/[,="+\\]/g, "");
+    // Capitalize each word
+    const words = cleaned
+        .trim()
+        .split(/\s+/)
+        .filter(Boolean)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1));
+    return words.join(" ") || "App";
+}
+/**
+ * Extracts app display name from native strings.xml or package.json
+ */
+async function getNativeAppName() {
+    const cwd = process.cwd();
+    // Try android strings.xml
+    const stringsPath = path_1.default.join(cwd, "android", "app", "src", "main", "res", "values", "strings.xml");
+    if (await fs_extra_1.default.pathExists(stringsPath)) {
+        try {
+            const content = await fs_extra_1.default.readFile(stringsPath, "utf8");
+            const match = content.match(/<string\s+name=["']app_name["']>([^<]+)<\/string>/);
+            if (match && match[1]) {
+                return match[1].trim();
+            }
+        }
+        catch { }
+    }
+    // Try package.json
+    const pkgPath = path_1.default.join(cwd, "package.json");
+    if (await fs_extra_1.default.pathExists(pkgPath)) {
+        try {
+            const pkg = await fs_extra_1.default.readJson(pkgPath);
+            if (pkg.displayName)
+                return pkg.displayName;
+            if (pkg.productName)
+                return pkg.productName;
+            if (pkg.name)
+                return toProperName(pkg.name);
+        }
+        catch { }
+    }
+    return "App";
+}
+/**
+ * Extracts package name / applicationId from Gradle or AndroidManifest
+ */
+async function getNativePackageName() {
+    const cwd = process.cwd();
+    const candidateFiles = [
+        path_1.default.join(cwd, "android", "app", "build.gradle"),
+        path_1.default.join(cwd, "android", "app", "build.gradle.kts"),
+        path_1.default.join(cwd, "android", "app", "src", "main", "AndroidManifest.xml"),
+    ];
+    for (const file of candidateFiles) {
+        if (await fs_extra_1.default.pathExists(file)) {
+            try {
+                const content = await fs_extra_1.default.readFile(file, "utf8");
+                const appIdMatch = content.match(/(?:applicationId|namespace)\s*=?\s*["']([a-zA-Z0-9_.]+)["']/);
+                if (appIdMatch && appIdMatch[1]) {
+                    return appIdMatch[1];
+                }
+                const manifestMatch = content.match(/package=["']([a-zA-Z0-9_.]+)["']/);
+                if (manifestMatch && manifestMatch[1]) {
+                    return manifestMatch[1];
+                }
+            }
+            catch { }
+        }
+    }
+    return null;
+}

package/dist/utils/signing.d.ts

@@ -0,0 +1,11 @@
+export interface KeystoreConfig {
+    keystorePath: string;
+    ksAlias: string;
+    ksPass: string;
+    keyPass: string;
+}
+export declare function updateEnvLocal(vars: Record<string, string>): Promise<void>;
+export declare function printKeystoreWarning(keystorePath: string): void;
+export declare function ensureOrPromptKeystore(requestedKeystore?: string, requestedAlias?: string, requestedStorePass?: string, requestedKeyPass?: string, appName?: string, outDir?: string): Promise<KeystoreConfig>;
+export declare function stripExistingSignatures(archivePath: string): Promise<void>;
+export declare function signArtifact(outputName: string, outDir: string, isAab: boolean, appName: string): Promise<void>;

package/dist/utils/signing.js

@@ -0,0 +1,311 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateEnvLocal = updateEnvLocal;
+exports.printKeystoreWarning = printKeystoreWarning;
+exports.ensureOrPromptKeystore = ensureOrPromptKeystore;
+exports.stripExistingSignatures = stripExistingSignatures;
+exports.signArtifact = signArtifact;
+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 promises_1 = __importDefault(require("node:readline/promises"));
+const node_process_1 = require("node:process");
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const project_js_1 = require("./project.js");
+async function promptQuestion(rl, query, defaultValue = "") {
+    const displayQuery = defaultValue
+        ? `${query} [${defaultValue}]: `
+        : `${query}: `;
+    const answer = (await rl.question(displayQuery)).trim();
+    return answer || defaultValue;
+}
+async function updateEnvLocal(vars) {
+    const envLocalPath = path_1.default.join(process.cwd(), ".env.local");
+    let content = "";
+    if (await fs_extra_1.default.pathExists(envLocalPath)) {
+        content = await fs_extra_1.default.readFile(envLocalPath, "utf8");
+    }
+    for (const [key, value] of Object.entries(vars)) {
+        const regex = new RegExp(`^${key}=.*$`, "m");
+        if (regex.test(content)) {
+            content = content.replace(regex, `${key}=${value}`);
+        }
+        else {
+            content = content
+                ? `${content.trimEnd()}\n${key}=${value}\n`
+                : `${key}=${value}\n`;
+        }
+        process.env[key] = value;
+    }
+    await fs_extra_1.default.writeFile(envLocalPath, content, "utf8");
+}
+function printKeystoreWarning(keystorePath) {
+    console.log(chalk_1.default.yellow("\n========================================================"));
+    console.log(chalk_1.default.red("IMPORTANT KEYSTORE BACKUP WARNING"));
+    console.log(chalk_1.default.yellow(` Generated new release keystore at: ${keystorePath}`));
+    console.log(chalk_1.default.green(" Configuration saved to: .env.local"));
+    console.log(chalk_1.default.white(" PLEASE BACK UP THIS KEYSTORE FILE!"));
+    console.log(chalk_1.default.white(" Losing this keystore means you CANNOT update your app"));
+    console.log(chalk_1.default.white(" on the Google Play Store in the future."));
+    console.log(chalk_1.default.yellow("========================================================\n"));
+}
+async function ensureOrPromptKeystore(requestedKeystore, requestedAlias, requestedStorePass, requestedKeyPass, appName = "Mobile App", outDir = "build") {
+    let ksFileName = requestedKeystore || process.env.KEYSTORE_PATH;
+    let keystorePath = "";
+    if (ksFileName) {
+        const p1 = path_1.default.resolve(process.cwd(), ksFileName);
+        const p2 = path_1.default.resolve(outDir, ksFileName);
+        if (await fs_extra_1.default.pathExists(p1)) {
+            keystorePath = p1;
+        }
+        else if (await fs_extra_1.default.pathExists(p2)) {
+            keystorePath = p2;
+        }
+    }
+    else {
+        const candidates = [
+            path_1.default.join(outDir, "release.jks"),
+            path_1.default.join(process.cwd(), "release.jks"),
+            path_1.default.join(outDir, "release.keystore"),
+            path_1.default.join(process.cwd(), "release.keystore"),
+            path_1.default.join(process.cwd(), "android", "app", "release.keystore"),
+            path_1.default.join(process.cwd(), "android", "app", "release.jks"),
+            path_1.default.join(process.cwd(), "android", "app", "my-upload-key.keystore"),
+        ];
+        for (const cand of candidates) {
+            if (await fs_extra_1.default.pathExists(cand)) {
+                keystorePath = cand;
+                break;
+            }
+        }
+    }
+    // If found on disk, return existing config
+    if (keystorePath && (await fs_extra_1.default.pathExists(keystorePath))) {
+        const ksAlias = requestedAlias || process.env.KEYSTORE_ALIAS || "release";
+        const ksPass = requestedStorePass || process.env.KEYSTORE_PASSWORD || "Password@1";
+        const keyPass = requestedKeyPass || process.env.KEY_PASSWORD || ksPass;
+        return { keystorePath, ksAlias, ksPass, keyPass };
+    }
+    // Keystore does NOT exist -> Interactively prompt or auto-generate
+    const targetKsRelative = requestedKeystore || path_1.default.join(outDir, "release.jks");
+    const targetKsPath = path_1.default.resolve(process.cwd(), targetKsRelative);
+    await fs_extra_1.default.ensureDir(path_1.default.dirname(targetKsPath));
+    const isInteractive = Boolean(process.stdin.isTTY);
+    let chosenAlias = requestedAlias || process.env.KEYSTORE_ALIAS || "";
+    let chosenStorePass = requestedStorePass || process.env.KEYSTORE_PASSWORD || "";
+    let chosenKeyPass = requestedKeyPass || process.env.KEY_PASSWORD || "";
+    let chosenPath = targetKsPath;
+    const properName = (0, project_js_1.toProperName)(appName || "Mobile App");
+    let cn = properName;
+    let ou = "Mobile App";
+    let org = properName;
+    let city = "Nairobi";
+    let state = "Nairobi";
+    let country = "KE";
+    if (isInteractive) {
+        console.log(chalk_1.default.yellow(`\nKeystore not found at '${targetKsRelative}'.`));
+        const rl = promises_1.default.createInterface({ input: node_process_1.stdin, output: node_process_1.stdout });
+        try {
+            const shouldCreate = await promptQuestion(rl, "Would you like to interactively create a new keystore now? (Y/n)", "Y");
+            if (shouldCreate.toLowerCase().startsWith("n")) {
+                console.error(chalk_1.default.red("Keystore creation cancelled. Cannot sign without a keystore."));
+                process.exit(1);
+            }
+            console.log(chalk_1.default.cyan("\n--- Keystore Configuration ---"));
+            const p = await promptQuestion(rl, "Keystore file path", path_1.default.relative(process.cwd(), targetKsPath).replace(/\\/g, "/"));
+            chosenPath = path_1.default.resolve(process.cwd(), p);
+            await fs_extra_1.default.ensureDir(path_1.default.dirname(chosenPath));
+            const defaultAlias = chosenAlias || node_crypto_1.default.randomBytes(16).toString("hex");
+            chosenAlias = await promptQuestion(rl, "Key alias", defaultAlias);
+            const defaultPass = chosenStorePass || node_crypto_1.default.randomBytes(16).toString("hex");
+            chosenStorePass = await promptQuestion(rl, "Keystore password", defaultPass);
+            // In modern PKCS12 keystores, key password must match store password
+            chosenKeyPass = chosenStorePass;
+            console.log(chalk_1.default.cyan("\n--- Certificate Details (Press Enter to accept defaults) ---"));
+            cn = await promptQuestion(rl, "Common Name (CN)", cn);
+            org = await promptQuestion(rl, "Organization (O)", org);
+            ou = await promptQuestion(rl, "Organizational Unit (OU)", ou);
+            city = await promptQuestion(rl, "Locality (L)", city);
+            state = await promptQuestion(rl, "State (ST)", state);
+            country = await promptQuestion(rl, "Country Code (C, 2-letter)", country);
+        }
+        finally {
+            rl.close();
+        }
+    }
+    else {
+        // Non-interactive / CI fallback
+        console.log(chalk_1.default.yellow(`Keystore not found. Generating new keystore at ${targetKsPath}...`));
+        if (!chosenAlias)
+            chosenAlias = node_crypto_1.default.randomBytes(16).toString("hex");
+        if (!chosenStorePass)
+            chosenStorePass = node_crypto_1.default.randomBytes(16).toString("hex");
+        chosenKeyPass = chosenStorePass;
+    }
+    // Generate the keystore with keytool
+    console.log(chalk_1.default.cyan(`\nGenerating keystore with keytool at ${chosenPath}...`));
+    await (0, execa_1.execa)("keytool", [
+        "-genkeypair",
+        "-v",
+        "-keystore",
+        chosenPath,
+        "-alias",
+        chosenAlias,
+        "-keyalg",
+        "RSA",
+        "-keysize",
+        "2048",
+        "-validity",
+        "10000",
+        "-storepass",
+        chosenStorePass,
+        "-keypass",
+        chosenKeyPass,
+        "-dname",
+        `CN=${cn}, OU=${ou}, O=${org}, L=${city}, ST=${state}, C=${country}`,
+    ]);
+    // Save generated credentials to .env.local
+    const relPath = path_1.default.relative(process.cwd(), chosenPath).replace(/\\/g, "/");
+    await updateEnvLocal({
+        KEYSTORE_PATH: relPath,
+        KEYSTORE_ALIAS: chosenAlias,
+        KEYSTORE_PASSWORD: chosenStorePass,
+        KEY_PASSWORD: chosenKeyPass,
+    });
+    printKeystoreWarning(chosenPath);
+    return {
+        keystorePath: chosenPath,
+        ksAlias: chosenAlias,
+        ksPass: chosenStorePass,
+        keyPass: chosenKeyPass,
+    };
+}
+async function stripExistingSignatures(archivePath) {
+    console.log(chalk_1.default.gray("Stripping existing signatures from bundle to ensure single certificate chain..."));
+    if (process.platform === "win32") {
+        const escapedPath = archivePath.replace(/'/g, "''");
+        await (0, execa_1.execa)("powershell", [
+            "-Command",
+            "Add-Type -AssemblyName System.IO.Compression.FileSystem; " +
+                "$zip = [System.IO.Compression.ZipFile]::Open('" +
+                escapedPath +
+                "', 'Update'); " +
+                "$entries = @($zip.Entries | Where-Object { $_.FullName -match '^META-INF/.*\\.(RSA|DSA|EC|SF)$' }); " +
+                "foreach ($e in $entries) { $e.Delete() }; " +
+                "$zip.Dispose()",
+        ]);
+    }
+    else {
+        try {
+            await (0, execa_1.execa)("zip", [
+                "-d",
+                archivePath,
+                "META-INF/*.SF",
+                "META-INF/*.RSA",
+                "META-INF/*.DSA",
+                "META-INF/*.EC",
+            ]);
+        }
+        catch {
+            // Ignored if no matching signature files found
+        }
+    }
+    // Clean up any detached idsig file for APKs
+    const idsigPath = `${archivePath}.idsig`;
+    if (await fs_extra_1.default.pathExists(idsigPath)) {
+        await fs_extra_1.default.remove(idsigPath);
+    }
+}
+async function signArtifact(outputName, outDir, isAab, appName) {
+    const { keystorePath, ksAlias, ksPass, keyPass } = await ensureOrPromptKeystore(undefined, undefined, undefined, undefined, appName, outDir);
+    const targetPath = path_1.default.join(outDir, outputName);
+    if (isAab) {
+        await stripExistingSignatures(targetPath);
+        console.log(chalk_1.default.cyan(`Signing ${outputName} with jarsigner...`));
+        try {
+            await (0, execa_1.execa)("jarsigner", [
+                "-sigalg",
+                "SHA256withRSA",
+                "-digestalg",
+                "SHA-256",
+                "-keystore",
+                keystorePath,
+                "-storepass",
+                ksPass,
+                "-keypass",
+                keyPass,
+                targetPath,
+                ksAlias,
+            ]);
+            console.log(chalk_1.default.green("Successfully signed AAB."));
+        }
+        catch (err) {
+            console.error(chalk_1.default.red(`jarsigner failed:\n${err.stderr || err.message}`));
+        }
+    }
+    else {
+        console.log(chalk_1.default.cyan(`Signing ${outputName} with apksigner...`));
+        let apksignerJar = "";
+        const androidHome = process.env.ANDROID_HOME || process.env.ANDROID_SDK_ROOT || "C:/Android";
+        const buildToolsDir = path_1.default.join(androidHome, "build-tools");
+        if (await fs_extra_1.default.pathExists(buildToolsDir)) {
+            const versions = await fs_extra_1.default.readdir(buildToolsDir);
+            if (versions.length > 0) {
+                versions.sort((a, b) => b.localeCompare(a));
+                apksignerJar = path_1.default.join(buildToolsDir, versions[0], "lib", "apksigner.jar");
+            }
+        }
+        if (await fs_extra_1.default.pathExists(apksignerJar)) {
+            try {
+                await (0, execa_1.execa)("java", [
+                    "-jar",
+                    apksignerJar,
+                    "sign",
+                    "--ks",
+                    keystorePath,
+                    "--ks-key-alias",
+                    ksAlias,
+                    "--ks-pass",
+                    `pass:${ksPass}`,
+                    "--key-pass",
+                    `pass:${keyPass}`,
+                    "--v4-signing-enabled",
+                    "false",
+                    targetPath,
+                ]);
+                console.log(chalk_1.default.green("Successfully signed APK."));
+            }
+            catch (err) {
+                console.log(chalk_1.default.yellow("Warning: apksigner failed."));
+                console.error(chalk_1.default.red(err.stderr || err.message));
+            }
+        }
+        else {
+            console.log(chalk_1.default.yellow("apksigner not found. Falling back to jarsigner for APK..."));
+            try {
+                await (0, execa_1.execa)("jarsigner", [
+                    "-sigalg",
+                    "SHA256withRSA",
+                    "-digestalg",
+                    "SHA-256",
+                    "-keystore",
+                    keystorePath,
+                    "-storepass",
+                    ksPass,
+                    "-keypass",
+                    keyPass,
+                    targetPath,
+                    ksAlias,
+                ]);
+                console.log(chalk_1.default.green("Successfully signed APK with jarsigner!"));
+            }
+            catch (err) {
+                console.error(chalk_1.default.red(`jarsigner failed:\n${err.stderr || err.message}`));
+            }
+        }
+    }
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "mobile-app-builder",
+  "version": "0.0.1",
+  "description": "Cross-platform CLI builder and signer for mobile applications (Expo, React Native, and Android projects)",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "mobile-builder": "./dist/cli.js",
+    "mobile-app-builder": "./dist/cli.js",
+    "app-builder": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "dev": "tsc --watch",
+    "format": "prettier --write ."
+  },
+  "keywords": [
+    "mobile",
+    "mobile-app",
+    "react-native",
+    "expo",
+    "android",
+    "builder",
+    "cli",
+    "signing",
+    "keystore",
+    "apksigner",
+    "jarsigner",
+    "aab",
+    "apk"
+  ],
+  "author": "George Chitechi",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^6.0.0",
+    "commander": "^15.0.0",
+    "dotenv": "^17.4.2",
+    "execa": "^10.0.1",
+    "fs-extra": "^11.4.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^22.20.3",
+    "prettier": "^3.9.7",
+    "typescript": "^7.0.2"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/georgechitechi/mobile-app-builder.git"
+  },
+  "bugs": {
+    "url": "https://github.com/georgechitechi/mobile-app-builder/issues"
+  },
+  "homepage": "https://github.com/georgechitechi/mobile-app-builder#readme"
+}