mobile-app-builder 0.0.1

package/dist/commands/sign.js

@@ -0,0 +1,185 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findLatestArtifact = findLatestArtifact;
+exports.signCommand = signCommand;
+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 dependencies_js_1 = require("../utils/dependencies.js");
+const signing_js_1 = require("../utils/signing.js");
+const project_js_1 = require("../utils/project.js");
+const config_js_1 = require("../utils/config.js");
+async function findLatestArtifact(extFilter) {
+    const searchDirs = [path_1.default.join(process.cwd(), "build"), process.cwd()];
+    for (const dir of searchDirs) {
+        if (await fs_extra_1.default.pathExists(dir)) {
+            const files = await fs_extra_1.default.readdir(dir);
+            const matched = files
+                .filter((f) => {
+                const ext = path_1.default.extname(f).toLowerCase();
+                return extFilter
+                    ? extFilter.includes(ext)
+                    : [".aab", ".apk"].includes(ext);
+            })
+                .map((f) => path_1.default.join(dir, f));
+            if (matched.length > 0) {
+                const stats = await Promise.all(matched.map(async (f) => ({ path: f, stat: await fs_extra_1.default.stat(f) })));
+                stats.sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs);
+                return stats[0].path;
+            }
+        }
+    }
+    return null;
+}
+async function signCommand(fileArg, options = {}) {
+    await (0, dependencies_js_1.ensureJava)();
+    let targetPath = fileArg || options.file;
+    if (!targetPath) {
+        targetPath = (await findLatestArtifact()) ?? undefined;
+    }
+    if (!targetPath) {
+        console.error(chalk_1.default.red("Error: No AAB or APK file specified or found in ./build or current directory."));
+        process.exit(1);
+    }
+    targetPath = path_1.default.resolve(process.cwd(), targetPath);
+    if (!(await fs_extra_1.default.pathExists(targetPath))) {
+        console.error(chalk_1.default.red(`Error: File not found: ${targetPath}`));
+        process.exit(1);
+    }
+    const ext = path_1.default.extname(targetPath).toLowerCase();
+    if (ext !== ".aab" && ext !== ".apk") {
+        console.error(chalk_1.default.red(`Error: Unsupported file type '${ext}'. Expected .aab or .apk.`));
+        process.exit(1);
+    }
+    const isAab = ext === ".aab";
+    console.log(chalk_1.default.cyan(`\nProcessing artifact: ${path_1.default.basename(targetPath)}`));
+    // Determine App Name from project configuration for certificate default
+    const { appName: detectedName } = await (0, config_js_1.getAppConfigInfo)();
+    const appName = (0, project_js_1.toProperName)(detectedName || "App");
+    // 1. Resolve Keystore Credentials (or interactively create if not found)
+    const { keystorePath, ksAlias, ksPass, keyPass } = await (0, signing_js_1.ensureOrPromptKeystore)(options.keystore, options.alias, options.storepass, options.keypass, appName, path_1.default.dirname(targetPath));
+    console.log(chalk_1.default.gray(`Using keystore: ${keystorePath} (alias: ${ksAlias})`));
+    // 2. Strip ALL existing signatures to prevent multiple certificate chains
+    await (0, signing_js_1.stripExistingSignatures)(targetPath);
+    // 3. Sign artifact
+    if (isAab) {
+        console.log(chalk_1.default.cyan(`Signing ${path_1.default.basename(targetPath)} 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}`));
+            process.exit(1);
+        }
+    }
+    else {
+        console.log(chalk_1.default.cyan(`Signing ${path_1.default.basename(targetPath)} 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 with apksigner!"));
+            }
+            catch (err) {
+                console.error(chalk_1.default.red(`apksigner failed:\n${err.stderr || err.message}`));
+                process.exit(1);
+            }
+        }
+        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}`));
+                process.exit(1);
+            }
+        }
+    }
+    // 4. Verify signature
+    if (options.verify !== false) {
+        console.log(chalk_1.default.cyan("\nVerifying certificate chain..."));
+        try {
+            const { stdout } = await (0, execa_1.execa)("jarsigner", [
+                "-verify",
+                "-verbose",
+                targetPath,
+            ]);
+            const signers = stdout.match(/- Signed by "[^"]+"/g);
+            if (signers && signers.length > 0) {
+                console.log(chalk_1.default.green(`Verified ${signers.length} certificate chain(s):`));
+                for (const s of signers) {
+                    console.log(chalk_1.default.gray(`  ${s}`));
+                }
+                if (signers.length === 1) {
+                    console.log(chalk_1.default.green("✓ Artifact is verified with exactly one certificate chain."));
+                }
+                else {
+                    console.log(chalk_1.default.yellow("⚠️ Warning: Multiple certificate chains detected!"));
+                }
+            }
+            else {
+                console.log(chalk_1.default.yellow("Note: Verified successfully without explicit signer lines."));
+            }
+        }
+        catch (err) {
+            console.log(chalk_1.default.yellow(`Warning during verification: ${err.message}`));
+        }
+    }
+}

package/dist/commands/upload.d.ts

@@ -0,0 +1,10 @@
+export interface UploadCommandOptions {
+    file?: string;
+    tag?: string;
+    title?: string;
+    notes?: string;
+    publish?: boolean;
+    track?: string;
+    prerelease?: boolean;
+}
+export declare function uploadCommand(fileArg?: string, options?: UploadCommandOptions): Promise<void>;

package/dist/commands/upload.js

@@ -0,0 +1,114 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadCommand = uploadCommand;
+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 dependencies_js_1 = require("../utils/dependencies.js");
+const github_js_1 = require("../utils/github.js");
+const sign_js_1 = require("./sign.js");
+async function uploadCommand(fileArg, options = {}) {
+    await (0, dependencies_js_1.ensureGitHubCLI)();
+    if (!(await (0, github_js_1.hasGitRemote)())) {
+        console.error(chalk_1.default.red("Error: No git remote found. Please connect your repository to GitHub ('git remote add origin <url>') before uploading."));
+        process.exit(1);
+    }
+    if (!(await (0, github_js_1.isGhAuthenticated)())) {
+        console.error(chalk_1.default.red("Error: GitHub CLI is not authenticated. Please run 'gh auth login' before uploading."));
+        process.exit(1);
+    }
+    let targetPath = fileArg || options.file;
+    if (!targetPath) {
+        targetPath = (await (0, sign_js_1.findLatestArtifact)()) ?? undefined;
+    }
+    if (!targetPath) {
+        console.error(chalk_1.default.red("Error: No AAB or APK file specified or found in ./build or current directory."));
+        process.exit(1);
+    }
+    targetPath = path_1.default.resolve(process.cwd(), targetPath);
+    if (!(await fs_extra_1.default.pathExists(targetPath))) {
+        console.error(chalk_1.default.red(`Error: File not found: ${targetPath}`));
+        process.exit(1);
+    }
+    const filename = path_1.default.basename(targetPath);
+    const ext = path_1.default.extname(targetPath).toLowerCase();
+    const isAab = ext === ".aab";
+    // Determine tag
+    let tag = options.tag;
+    if (!tag) {
+        const match = filename.match(/v\d+\.\d+\.\d+(?:-[a-zA-Z0-9_]+)?/);
+        if (match) {
+            tag = match[0];
+        }
+        else {
+            const pkgPath = path_1.default.join(process.cwd(), "package.json");
+            if (await fs_extra_1.default.pathExists(pkgPath)) {
+                try {
+                    const pkg = await fs_extra_1.default.readJson(pkgPath);
+                    if (pkg.version) {
+                        const profileSuffix = isAab ? "-prod" : "";
+                        tag = `v${pkg.version}${profileSuffix}`;
+                    }
+                }
+                catch { }
+            }
+        }
+    }
+    if (!tag) {
+        console.error(chalk_1.default.red("Error: Could not determine release tag. Please specify with --tag <tag> (e.g. --tag v1.0.0-prod)."));
+        process.exit(1);
+    }
+    const title = options.title || tag;
+    const notes = options.notes || "";
+    const isPrerelease = options.prerelease !== undefined
+        ? options.prerelease
+        : tag.includes("-dev") || tag.includes("-preview");
+    console.log(chalk_1.default.cyan(`\nUploading ${filename} to GitHub Release '${tag}'...`));
+    try {
+        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. Uploading asset with --clobber...`));
+            await (0, execa_1.execa)("gh", ["release", "upload", tag, targetPath, "--clobber"], {
+                stdio: "inherit",
+            });
+        }
+        else {
+            console.log(chalk_1.default.yellow(`Creating new release '${tag}' and uploading asset...`));
+            const createArgs = [
+                "release",
+                "create",
+                tag,
+                targetPath,
+                `--title=${title}`,
+                `--notes=${notes}`,
+            ];
+            if (isPrerelease) {
+                createArgs.push("--prerelease");
+            }
+            await (0, execa_1.execa)("gh", createArgs, { stdio: "inherit" });
+        }
+        console.log(chalk_1.default.green(`\n✓ Successfully uploaded ${filename} to release ${tag}!`));
+    }
+    catch (err) {
+        console.error(chalk_1.default.red(`\nError: Failed to upload release: ${err.stderr || err.message}`));
+        process.exit(1);
+    }
+    if (options.publish) {
+        if (isAab) {
+            const track = options.track || "alpha";
+            await (0, github_js_1.triggerGitHubWorkflow)(tag, track);
+        }
+        else {
+            console.log(chalk_1.default.yellow("Note: Skipping Play Store trigger (--publish is only applicable for .aab bundles)."));
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./commands/buildAndroid.js";
+export * from "./commands/doctor.js";
+export * from "./commands/sign.js";
+export * from "./commands/upload.js";
+export * from "./commands/buildIos.js";
+export * from "./utils/dependencies.js";
+export * from "./utils/config.js";
+export * from "./utils/gradle.js";
+export * from "./utils/signing.js";
+export * from "./utils/github.js";
+export * from "./utils/project.js";

package/dist/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./commands/buildAndroid.js"), exports);
+__exportStar(require("./commands/doctor.js"), exports);
+__exportStar(require("./commands/sign.js"), exports);
+__exportStar(require("./commands/upload.js"), exports);
+__exportStar(require("./commands/buildIos.js"), exports);
+__exportStar(require("./utils/dependencies.js"), exports);
+__exportStar(require("./utils/config.js"), exports);
+__exportStar(require("./utils/gradle.js"), exports);
+__exportStar(require("./utils/signing.js"), exports);
+__exportStar(require("./utils/github.js"), exports);
+__exportStar(require("./utils/project.js"), exports);

package/dist/utils/config.d.ts

@@ -0,0 +1,7 @@
+export declare function syncVersionCode(profileName: string, increment?: boolean, projectType?: "expo" | "react-native"): Promise<number>;
+export declare function getAppConfigInfo(projectType?: "expo" | "react-native"): Promise<{
+    appName: string;
+    appVersion: string;
+    appPackageName: string | null;
+}>;
+export declare function generateNativeProject(clean: boolean): Promise<void>;

package/dist/utils/config.js

@@ -0,0 +1,175 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncVersionCode = syncVersionCode;
+exports.getAppConfigInfo = getAppConfigInfo;
+exports.generateNativeProject = generateNativeProject;
+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 project_js_1 = require("./project.js");
+const gradle_js_1 = require("./gradle.js");
+async function syncVersionCode(profileName, increment = false, projectType = "react-native") {
+    console.log(chalk_1.default.cyan("\nStep 03: Resolving and syncing Android versionCode..."));
+    if (projectType !== "expo") {
+        const localCode = await (0, gradle_js_1.getGradleVersionCode)();
+        if (increment) {
+            const nextCode = localCode + 1;
+            console.log(chalk_1.default.green(`Incrementing Android versionCode from ${localCode} to ${nextCode}.`));
+            return nextCode;
+        }
+        console.log(chalk_1.default.green(`Using current Android versionCode: ${localCode}`));
+        return localCode;
+    }
+    // Expo project: attempt remote version sync
+    try {
+        const { stdout } = await (0, execa_1.execa)("npx", [
+            "--yes",
+            "--quiet",
+            "eas-cli",
+            "build:version:get",
+            "--platform",
+            "android",
+            "--profile",
+            profileName,
+            "--json",
+            "--non-interactive",
+        ]);
+        const idx = stdout.indexOf("{");
+        if (idx >= 0) {
+            const obj = JSON.parse(stdout.substring(idx));
+            const remoteVersionCode = obj.versionCode || 1;
+            console.log(chalk_1.default.green(`Remote Version Code found: ${remoteVersionCode}`));
+            if (increment) {
+                try {
+                    const nextVersionCode = parseInt(String(remoteVersionCode), 10) + 1;
+                    console.log(chalk_1.default.yellow(`\nNOTE: Syncing new version code (${nextVersionCode}) into remote registry...`));
+                    if (process.platform === "win32") {
+                        require("child_process").exec(`powershell -WindowStyle Hidden -Command "Start-Sleep -Seconds 2; Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.SendKeys]::SendWait('${nextVersionCode}{ENTER}')"`);
+                    }
+                    else if (process.platform === "darwin") {
+                        require("child_process").exec(`osascript -e 'delay 2' -e 'tell application "System Events" to keystroke "${nextVersionCode}" & return'`);
+                    }
+                    await (0, execa_1.execa)("npx", [
+                        "--yes",
+                        "--quiet",
+                        "eas-cli",
+                        "build:version:set",
+                        "--platform",
+                        "android",
+                        "--profile",
+                        profileName,
+                    ], { stdio: "inherit" });
+                }
+                catch (err) {
+                    console.log(chalk_1.default.yellow("Failed to sync incremented version code to remote service."));
+                }
+            }
+            else {
+                console.log(chalk_1.default.gray(`Using current remote version code (${remoteVersionCode}) without incrementing.`));
+            }
+            return remoteVersionCode;
+        }
+    }
+    catch (err) {
+        const fallbackCode = await (0, gradle_js_1.getGradleVersionCode)();
+        const finalCode = increment ? fallbackCode + 1 : fallbackCode;
+        console.log(chalk_1.default.gray(`Using local Gradle versionCode (${finalCode}).`));
+        return finalCode;
+    }
+    return 1;
+}
+async function getAppConfigInfo(projectType = "react-native") {
+    let appName = "app";
+    let appVersion = "unknown";
+    let appPackageName = null;
+    // Try Expo config if Expo project
+    if (projectType === "expo") {
+        try {
+            const { stdout } = await (0, execa_1.execa)("npx", [
+                "--yes",
+                "--quiet",
+                "expo",
+                "config",
+                "--json",
+            ]);
+            const idx = stdout.indexOf("{");
+            if (idx >= 0) {
+                const config = JSON.parse(stdout.substring(idx));
+                appName = (config.name || "app").replace(/ /g, "-");
+                appVersion = config.version || "unknown";
+                if (config.android?.package) {
+                    appPackageName = config.android.package;
+                }
+            }
+        }
+        catch { }
+    }
+    // Fallback or Native React Native project inspection
+    const pkgPath = path_1.default.join(process.cwd(), "package.json");
+    if (await fs_extra_1.default.pathExists(pkgPath)) {
+        try {
+            const pkg = await fs_extra_1.default.readJson(pkgPath);
+            if (appVersion === "unknown" && pkg.version) {
+                appVersion = pkg.version;
+            }
+            if (appName === "app") {
+                const rawName = pkg.displayName || pkg.productName || pkg.name;
+                if (rawName) {
+                    appName = rawName.replace(/ /g, "-");
+                }
+            }
+        }
+        catch { }
+    }
+    if (appName === "app") {
+        const nativeName = await (0, project_js_1.getNativeAppName)();
+        appName = nativeName.replace(/ /g, "-");
+    }
+    if (!appPackageName) {
+        appPackageName = await (0, project_js_1.getNativePackageName)();
+    }
+    if (!appPackageName) {
+        const files = [
+            "app.config.ts",
+            "app.config.js",
+            "app.json",
+            "android/app/build.gradle",
+        ];
+        for (const file of files) {
+            const p = path_1.default.join(process.cwd(), file);
+            if (await fs_extra_1.default.pathExists(p)) {
+                const content = await fs_extra_1.default.readFile(p, "utf8");
+                const match = content.match(/package(?:Name|)["':\s]+([a-zA-Z0-9\._]+)["']/i) ||
+                    content.match(/applicationId\s+["']([^"']+)["']/);
+                if (match) {
+                    appPackageName = match[1];
+                    break;
+                }
+            }
+        }
+    }
+    return { appName, appVersion, appPackageName };
+}
+async function generateNativeProject(clean) {
+    if (clean || !(await fs_extra_1.default.pathExists(path_1.default.join(process.cwd(), "android")))) {
+        if (await fs_extra_1.default.pathExists(path_1.default.join(process.cwd(), "android", "gradlew"))) {
+            console.log(chalk_1.default.gray("Stopping Gradle daemon to release file locks..."));
+            try {
+                await (0, execa_1.execa)(process.platform === "win32" ? ".\\gradlew.bat" : "./gradlew", ["--stop"], { cwd: "android" });
+            }
+            catch { }
+        }
+        if (await fs_extra_1.default.pathExists("android")) {
+            await fs_extra_1.default.remove("android");
+        }
+        console.log(chalk_1.default.cyan("\nStep 04: Generating Android native project files..."));
+        await (0, execa_1.execa)("npx", ["expo", "prebuild", "--platform", "android", "--clean"], { stdio: "inherit" });
+    }
+    else {
+        console.log(chalk_1.default.gray("Skipping regeneration to use existing native cache."));
+    }
+}

package/dist/utils/dependencies.d.ts

@@ -0,0 +1,13 @@
+export declare function ensureGit(): Promise<void>;
+export declare function ensureNode(minMajorVersion?: number): Promise<void>;
+export declare function ensureGitHubCLI(): Promise<void>;
+export declare function ensureJava(): Promise<void>;
+export declare function ensureAndroidSdk(): Promise<string>;
+export type ProjectType = "expo" | "react-native";
+export interface ProjectInfo {
+    type: ProjectType;
+    isManaged: boolean;
+    hasAndroidDir: boolean;
+}
+export declare function detectProjectType(): Promise<ProjectInfo | null>;
+export declare function ensureProjectType(): Promise<ProjectInfo>;