mobile-app-builder 0.0.1

package/README.md

@@ -0,0 +1,191 @@
+# Mobile App Builder (`mobile-app-builder`)
+
+[![npm version](https://badge.fury.io/js/mobile-app-builder.svg)](https://badge.fury.io/js/mobile-app-builder)
+[![npm downloads](https://img.shields.io/npm/dt/mobile-app-builder.svg)](https://www.npmjs.com/package/mobile-app-builder)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+A cross-platform CLI builder and signer for **Expo** (Managed & Bare), **Native React Native**, and **Android** mobile projects. It automates bootstrapping dependencies, building, signing with keystores, and publishing applications.
+
+## Table of Contents
+
+- [Introduction](#introduction)
+- [Features](#features)
+- [Prerequisites](#prerequisites)
+- [Installation](#installation)
+- [Usage](#usage)
+- [Command Options](#command-options)
+- [Standalone Artifact Signing](#standalone-artifact-signing)
+- [Build Profiles](#build-profiles)
+- [Workflow Steps](#workflow-steps)
+- [Development](#development)
+- [License](#license)
+
+## Introduction
+
+`mobile-app-builder` is an all-in-one CLI tool designed to streamline mobile builds for both **Expo** and **Native (Bare) React Native** projects. Instead of wrestling with complex cloud build configurations or manual Gradle signing setups, this tool automatically detects your project type, manages Android configurations safely, compiles APKs or AABs via Gradle, signs them with production or custom keystores, and optionally publishes to GitHub Releases or Google Play Store.
+
+## Features
+
+- **Dual Project Support**: Works seamlessly on Expo projects (Managed CNG and Bare) as well as Native (Bare) React Native projects.
+- **Permanent Android Folder Safety**: Automatically detects Native/Bare projects and **never** deletes or wipes your source-controlled `android/` folder.
+- **Automated Native Generation**: Automatically runs native prebuild only for Managed Expo projects where the `android/` directory is ephemeral.
+- **Universal Signing Pipeline**: Strips prior signatures and signs `.apk` and `.aab` artifacts using `apksigner` and `jarsigner`. Generates release keystores interactively and saves configurations to `.env.local`.
+- **Dynamic Configuration & Versioning**: Automatically syncs version codes and version names directly into `package.json`, `app.json`, and `android/app/build.gradle`.
+- **Multiple Build Profiles**: Supports `dev` (Debug APK), `preview` (Release APK), and `prod` (Release AAB).
+- **Environment Management**: Inject specific `.env` files for different build flavors.
+- **Publishing & CI Integration**: Generates GitHub Actions workflows (for production AABs), creates GitHub Releases, and triggers Play Store rollouts.
+
+## Prerequisites
+
+Ensure you have the following installed on your machine (the `doctor` command can verify or install missing dependencies for you):
+
+- [Node.js](https://nodejs.org/) (>= 22.0.0)
+- [Java Development Kit (JDK 21)](https://adoptium.net/)
+- [Android SDK](https://developer.android.com/studio) (Command Line Tools, Platform Tools, Build Tools)
+- [Git](https://git-scm.com/)
+- [GitHub CLI (gh)](https://cli.github.com/) (Required if using GitHub Release / Publish flags)
+
+## Installation
+
+You can install `mobile-app-builder` directly from npm, or use it locally.
+
+```bash
+# Global installation
+npm install -g mobile-app-builder
+
+# Local installation in a React Native or Expo project
+npm install --save-dev mobile-app-builder
+```
+
+## Usage
+
+Navigate to your React Native or Expo project directory and run the command using `mobile-builder` (or `mobile-app-builder`):
+
+```bash
+# Check environment and dependencies
+npx mobile-builder doctor
+
+# Build Android app
+npx mobile-builder android [options]
+```
+
+### Examples
+
+**Build a development APK:**
+
+```bash
+npx mobile-builder android --dev
+```
+
+**Build a release preview APK:**
+
+```bash
+npx mobile-builder android --preview
+```
+
+**Build a production AAB and publish:**
+
+```bash
+npx mobile-builder android --prod --publish --track production --notes "Production release"
+```
+
+**Test the build pipeline without running Gradle:**
+
+```bash
+npx mobile-builder android --preview --dry-run
+```
+
+## Standalone Artifact Signing
+
+Already built an APK or AAB? You can sign or re-sign it directly with:
+
+```bash
+# Signs the latest AAB or APK found in ./build or current directory
+npx mobile-builder sign
+
+# Sign a specific artifact with a specified keystore
+npx mobile-builder sign ./build/my-app.aab --keystore ./release.jks --alias my-key
+```
+
+## Command Options
+
+| Option            | Description                                                               |
+| ----------------- | ------------------------------------------------------------------------- |
+| `--dev`           | Build a Development APK (`assembleDebug`, preserves cache)                |
+| `--preview`       | Build a Preview APK (`assembleRelease`)                                   |
+| `--prod`          | Build a Production AAB (`bundleRelease`)                                  |
+| `--clean`         | Forces clean regeneration (Managed Expo only)                             |
+| `--bump`          | Explicitly bump patch version in `package.json`                           |
+| `--no-bump`       | Skip bumping patch version in `package.json`                              |
+| `--publish`       | Publish to Google Play Store (via GitHub Actions workflow for `--prod`)   |
+| `--track <track>` | Google Play Store track (e.g., `production`, `beta`, `alpha`, `internal`) |
+| `--notes <notes>` | Release notes for GitHub Release                                          |
+| `--dry-run`       | Run the full script but skip Gradle build, signing, and publishing        |
+| `--env <file>`    | Path to a specific environment file to load (e.g., `.env.production`)     |
+| `--cleanup`       | Force cleanup of ephemeral `android/` directory (Managed Expo only)       |
+| `--no-cleanup`    | Keep the generated `android/` folder after build                          |
+
+## Build Profiles
+
+The builder automatically maps profiles to the correct build types and artifact formats:
+
+1. **Dev (`--dev`)**
+   - **Profile Name**: `development`
+   - **Build Task**: `assembleDebug`
+   - **Output**: `app-debug.apk`
+   - **Versioning**: Preserves current version string and local `versionCode`
+   - **GitHub Release**: Marked as **Pre-release**
+   - **Speed**: Preserves `android/` folder and Gradle daemon for fast incremental rebuilds
+
+2. **Preview (`--preview`)**
+   - **Profile Name**: `preview`
+   - **Build Task**: `assembleRelease`
+   - **Output**: `app-release.apk`
+   - **Signing**: Automatically signed with release keystore
+   - **GitHub Release**: Marked as **Pre-release**
+
+3. **Prod (`--prod`)**
+   - **Profile Name**: `production`
+   - **Build Task**: `bundleRelease`
+   - **Output**: `app-release.aab`
+   - **Versioning**: Bumps patch version and increments `versionCode`
+   - **Signing**: Strips prior signatures and signs AAB via `jarsigner`
+   - **GitHub Release**: Marked as official **Latest Release**
+   - **CI/CD**: Generates `.github/workflows/publish.yml` and triggers Play Store rollout if `--publish` is specified
+
+## Workflow Steps
+
+When you run a build, the CLI automatically performs the following steps:
+
+1. **Project Detection**: Detects whether the project is Expo (Managed or Bare) or Native React Native.
+2. **Bootstrapping**: Validates system dependencies (Node, Java 21, Android SDK, Git, gh).
+3. **Version Management**: Bumps `package.json` (for prod or if `--bump` is set) and syncs `versionCode` into Gradle or EAS.
+4. **Native Generation (Expo Managed only)**: Generates Android project files (`expo prebuild`). Skipped for Native React Native and Bare projects.
+5. **Gradle Patching**: Injects memory optimizations, caching, daemon, and incremental settings into `gradle.properties`.
+6. **Gradle Build**: Runs the Gradle wrapper with `--build-cache`, `--parallel`, and `--configure-on-demand`.
+7. **Signing**: Strips any previous signatures and signs the artifact with keystore credentials (`apksigner` for APK, `jarsigner` for AAB).
+8. **Copying**: Moves the finished `.apk` or `.aab` to the `build/` directory in the root.
+9. **GitHub Release**: Automatically creates/updates a GitHub Release (tagged as **Pre-release** for dev/preview). Skips gracefully if remote is unconfigured.
+10. **Play Store Rollout (Optional)**: If `--publish` is passed with `--prod`, triggers the Google Play Store deployment workflow.
+11. **Cleanup**: Cleans up ephemeral `android/` only on Managed Expo builds, while strictly preserving permanent native source code.
+
+## Development
+
+```bash
+# Clone the repository
+git clone https://github.com/georgechitechi/mobile-app-builder.git
+cd mobile-app-builder
+
+# Install dependencies
+npm install
+
+# Watch mode for TypeScript
+npm run dev
+
+# Build the final dist
+npm run build
+```
+
+## License
+
+MIT License. See [LICENSE](LICENSE) for more details.

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dotenv_1 = require("dotenv");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+// Load .env and .env.local from the current working directory
+const cwd = process.cwd();
+if (fs_1.default.existsSync(path_1.default.join(cwd, ".env"))) {
+    (0, dotenv_1.config)({ path: path_1.default.join(cwd, ".env"), quiet: true });
+}
+if (fs_1.default.existsSync(path_1.default.join(cwd, ".env.local"))) {
+    (0, dotenv_1.config)({ path: path_1.default.join(cwd, ".env.local"), quiet: true });
+}
+const commander_1 = require("commander");
+const buildAndroid_js_1 = require("./commands/buildAndroid.js");
+const doctor_js_1 = require("./commands/doctor.js");
+const buildIos_js_1 = require("./commands/buildIos.js");
+const sign_js_1 = require("./commands/sign.js");
+const upload_js_1 = require("./commands/upload.js");
+const pkgJsonPath = path_1.default.resolve(__dirname, "../package.json");
+let version = "0.0.1";
+try {
+    const pkg = JSON.parse(fs_1.default.readFileSync(pkgJsonPath, "utf-8"));
+    if (pkg.version) {
+        version = pkg.version;
+    }
+}
+catch { }
+commander_1.program
+    .name("mobile-builder")
+    .description("Cross-platform CLI builder and signer for mobile applications (Expo, React Native, and Android projects)")
+    .version(version);
+commander_1.program
+    .command("doctor")
+    .aliases(["doc", "health"])
+    .description("Check dependencies and bootstrap environment")
+    .action(() => {
+    (0, doctor_js_1.doctor)().catch((err) => {
+        console.error(err);
+        process.exit(1);
+    });
+});
+commander_1.program
+    .command("android")
+    .aliases(["build:android", "ba"])
+    .description("Build Android app (APK or AAB)")
+    .option("--dev", "Build development profile")
+    .option("--preview", "Build preview profile")
+    .option("--prod", "Build production profile (AAB)")
+    .option("--clean", "Clean before building")
+    .option("--bump", "Explicitly bump patch version in package.json")
+    .option("--no-bump", "Skip bumping patch version in package.json")
+    .option("--publish", "Publish to Play Store")
+    .option("--track <track>", "Play Store Track", "alpha")
+    .option("--notes <notes>", "Release Notes")
+    .option("--dry-run", "Validate environment without running Gradle")
+    .option("--env <file>", "Path to .env file to inject")
+    .option("--cleanup", "Force cleaning up the android folder after build")
+    .option("--no-cleanup", "Skip cleaning up the android folder after build")
+    .action((options) => {
+    (0, buildAndroid_js_1.buildAndroid)(options).catch((err) => {
+        console.error(err);
+        process.exit(1);
+    });
+});
+commander_1.program
+    .command("sign [file]")
+    .aliases(["artifact:sign", "resign"])
+    .description("Sign an existing AAB or APK while stripping any prior signatures")
+    .option("-f, --file <path>", "Path to the AAB or APK file")
+    .option("-k, --keystore <path>", "Keystore file path")
+    .option("-a, --alias <alias>", "Keystore key alias")
+    .option("-p, --storepass <password>", "Keystore store password")
+    .option("--keypass <password>", "Key password")
+    .option("--no-verify", "Skip verifying signature after signing")
+    .action((file, options) => {
+    (0, sign_js_1.signCommand)(file, options).catch((err) => {
+        console.error(err);
+        process.exit(1);
+    });
+});
+commander_1.program
+    .command("upload [file]")
+    .aliases(["release:upload", "up"])
+    .description("Upload an existing AAB or APK to GitHub Releases")
+    .option("-f, --file <path>", "Path to the AAB or APK file")
+    .option("-t, --tag <tag>", "GitHub release tag (e.g. v1.0.0 or v1.0.0-prod)")
+    .option("--title <title>", "Release title")
+    .option("-n, --notes <notes>", "Release notes")
+    .option("--publish", "Trigger Play Store deployment workflow after upload (AAB only)")
+    .option("--track <track>", "Play Store Track (alpha, beta, production, internal)", "alpha")
+    .option("--prerelease", "Mark GitHub release as pre-release")
+    .action((file, options) => {
+    (0, upload_js_1.uploadCommand)(file, options).catch((err) => {
+        console.error(err);
+        process.exit(1);
+    });
+});
+commander_1.program
+    .command("ios")
+    .aliases(["build:ios", "bi"])
+    .description("Build iOS app (coming soon)")
+    .action(() => {
+    (0, buildIos_js_1.buildIos)().catch((err) => {
+        console.error(err);
+        process.exit(1);
+    });
+});
+commander_1.program.parse(process.argv);

package/dist/commands/buildAndroid.d.ts

@@ -0,0 +1,15 @@
+export interface BuildAndroidOptions {
+    dev?: boolean;
+    preview?: boolean;
+    prod?: boolean;
+    clean?: boolean;
+    bump?: boolean;
+    noBump?: boolean;
+    publish?: boolean;
+    track: string;
+    notes?: string;
+    dryRun?: boolean;
+    env?: string;
+    cleanup?: boolean;
+}
+export declare function buildAndroid(options: BuildAndroidOptions): Promise<void>;

package/dist/commands/buildAndroid.js

@@ -0,0 +1,160 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAndroid = buildAndroid;
+const chalk_1 = __importDefault(require("chalk"));
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const execa_1 = require("execa");
+const dotenv_1 = __importDefault(require("dotenv"));
+const dependencies_js_1 = require("../utils/dependencies.js");
+const config_js_1 = require("../utils/config.js");
+const gradle_js_1 = require("../utils/gradle.js");
+const signing_js_1 = require("../utils/signing.js");
+const github_js_1 = require("../utils/github.js");
+const project_js_1 = require("../utils/project.js");
+async function buildAndroid(options) {
+    const projectInfo = await (0, dependencies_js_1.ensureProjectType)();
+    console.log(chalk_1.default.cyan("Bootstrapping drop-in tool architecture..."));
+    if (options.env) {
+        console.log(chalk_1.default.cyan(`Loading environment variables from ${options.env}...`));
+        dotenv_1.default.config({
+            path: path_1.default.resolve(process.cwd(), options.env),
+            quiet: true,
+        });
+    }
+    const profile = options.dev ? "dev" : options.prod ? "prod" : "preview";
+    const fullProfileName = options.dev
+        ? "development"
+        : options.prod
+            ? "production"
+            : "preview";
+    const isAab = profile === "prod";
+    const buildType = profile === "dev" ? "Debug" : "Release";
+    const assembleTask = isAab
+        ? "bundleRelease"
+        : profile === "dev"
+            ? "assembleDebug"
+            : "assembleRelease";
+    const apkDir = profile === "dev" ? "debug" : "release";
+    const ext = isAab ? "aab" : "apk";
+    process.env.NODE_ENV = isAab ? "production" : "development";
+    process.env.APP_VARIANT = fullProfileName;
+    if (projectInfo.type === "expo") {
+        process.env.EAS_BUILD_PROFILE = fullProfileName;
+    }
+    try {
+        await (0, dependencies_js_1.ensureGit)();
+        await (0, dependencies_js_1.ensureNode)(22);
+        await (0, dependencies_js_1.ensureGitHubCLI)();
+        await (0, dependencies_js_1.ensureJava)();
+        await (0, dependencies_js_1.ensureAndroidSdk)();
+        const shouldBump = options.bump === true || (profile === "prod" && options.noBump !== true);
+        await (0, project_js_1.syncProjectVersionConfig)(shouldBump, projectInfo.type);
+        const currentVersionCode = await (0, config_js_1.syncVersionCode)(fullProfileName, shouldBump, projectInfo.type);
+        const { appName, appVersion, appPackageName } = await (0, config_js_1.getAppConfigInfo)(projectInfo.type);
+        if (!appPackageName) {
+            console.log(chalk_1.default.red("Error: Could not dynamically determine Android package name / applicationId!"));
+            process.exit(1);
+        }
+        const outputName = `${appName}-v${appVersion}-${profile}.${ext}`;
+        if (isAab) {
+            await (0, github_js_1.generatePublishWorkflow)(appPackageName);
+        }
+        if (projectInfo.isManaged) {
+            await (0, config_js_1.generateNativeProject)(!!options.clean);
+        }
+        else {
+            console.log(chalk_1.default.gray(`\nStep 04: Using existing native android project (${projectInfo.type === "expo" ? "Bare Expo" : "Native React Native"}). Skipping generation.`));
+            if (!(await fs_extra_1.default.pathExists(path_1.default.join(process.cwd(), "android")))) {
+                console.log(chalk_1.default.red("Error: 'android' directory not found in project root!"));
+                process.exit(1);
+            }
+        }
+        await (0, gradle_js_1.patchGradleProperties)();
+        await (0, gradle_js_1.syncBuildGradle)(appVersion, currentVersionCode);
+        console.log(chalk_1.default.cyan(`\nStep 06: Building ${buildType} ${ext} (${assembleTask})...`));
+        if (options.dryRun) {
+            console.log(chalk_1.default.yellow("\nDry run requested. Skipping Gradle build, signing, and publishing."));
+            console.log(chalk_1.default.green("\nDry run completed successfully!"));
+            return;
+        }
+        await (0, gradle_js_1.runGradleBuild)(assembleTask);
+        console.log(chalk_1.default.cyan(`\nStep 07: Copying ${ext} to build folder...`));
+        const outDir = path_1.default.join(process.cwd(), "build");
+        await fs_extra_1.default.ensureDir(outDir);
+        const artifactSubDir = isAab ? "bundle/release" : `apk/${apkDir}`;
+        const artifactDir = path_1.default.join(process.cwd(), "android/app/build/outputs", artifactSubDir);
+        const sourceName = isAab
+            ? "app-release.aab"
+            : profile === "dev"
+                ? "app-debug.apk"
+                : (await fs_extra_1.default.pathExists(path_1.default.join(artifactDir, "app-release-unsigned.apk")))
+                    ? "app-release-unsigned.apk"
+                    : "app-release.apk";
+        const artifactPath = path_1.default.join(artifactDir, sourceName);
+        const destPath = path_1.default.join(outDir, outputName);
+        if (await fs_extra_1.default.pathExists(artifactPath)) {
+            await fs_extra_1.default.copy(artifactPath, destPath, { overwrite: true });
+            if (!(await fs_extra_1.default.pathExists(destPath))) {
+                console.log(chalk_1.default.red(`Error: Failed to confirm ${ext} in build folder at ${destPath}.`));
+                process.exit(1);
+            }
+            console.log(chalk_1.default.green(`Success! ${ext} generated at ${destPath}`));
+        }
+        else {
+            console.log(chalk_1.default.red(`Error: ${ext} not found at expected location (${artifactPath}).`));
+            process.exit(1);
+        }
+        console.log(chalk_1.default.cyan(`\nStep 08: Signing ${ext}...`));
+        await (0, signing_js_1.signArtifact)(outputName, outDir, isAab, appName);
+        const tag = `v${appVersion}${profile ? "-" + profile : ""}`;
+        const isPrerelease = profile !== "prod";
+        const published = await (0, github_js_1.publishGitHubRelease)(tag, destPath, tag, options.notes || "", fullProfileName, isPrerelease);
+        if (options.publish && isAab && published) {
+            await (0, github_js_1.triggerGitHubWorkflow)(tag, options.track);
+        }
+        else if (options.publish && isAab && !published) {
+            console.log(chalk_1.default.yellow(`Note: Skipping Play Store trigger because artifact could not be published to GitHub Releases.`));
+        }
+        else if (options.publish && !isAab) {
+            console.log(chalk_1.default.yellow(`Note: Skipping Play Store trigger (only production AAB builds can be deployed to Play Store).`));
+        }
+        console.log(chalk_1.default.green("\nBuild completed successfully!"));
+    }
+    finally {
+        const shouldCleanup = projectInfo.isManaged &&
+            (options.cleanup !== undefined ? options.cleanup : profile !== "dev");
+        if (shouldCleanup) {
+            console.log(chalk_1.default.gray("\nCleaning up ephemeral android folder..."));
+            if (await fs_extra_1.default.pathExists("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 { }
+                }
+                try {
+                    await fs_extra_1.default.remove("android");
+                    console.log(chalk_1.default.green("Cleanup completed."));
+                }
+                catch (err) {
+                    console.log(chalk_1.default.yellow(`Cleanup partially failed (file lock). Run 'gradlew --stop' if you need to manually delete it.`));
+                }
+            }
+        }
+        else {
+            if (projectInfo.isManaged) {
+                console.log(chalk_1.default.gray(profile === "dev"
+                    ? "\nPreserving android/ folder and Gradle daemon for fast rebuilds (use --cleanup to delete)."
+                    : "\nSkipping cleanup (--no-cleanup specified). The android/ folder has been left intact."));
+            }
+            else {
+                console.log(chalk_1.default.gray("\nPreserving permanent android/ source directory intact."));
+            }
+        }
+    }
+}

package/dist/commands/buildIos.d.ts

@@ -0,0 +1 @@
+export declare function buildIos(): Promise<void>;

package/dist/commands/buildIos.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildIos = buildIos;
+const chalk_1 = __importDefault(require("chalk"));
+async function buildIos() {
+    console.log(chalk_1.default.cyan("Starting iOS build pipeline..."));
+    console.log(chalk_1.default.yellow("iOS build support is coming soon! This command is currently a placeholder."));
+}

package/dist/commands/doctor.d.ts

@@ -0,0 +1 @@
+export declare function doctor(): Promise<void>;

package/dist/commands/doctor.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doctor = doctor;
+const chalk_1 = __importDefault(require("chalk"));
+const dependencies_js_1 = require("../utils/dependencies.js");
+async function doctor() {
+    try {
+        await (0, dependencies_js_1.ensureProjectType)();
+        console.log(chalk_1.default.cyan("Running environment diagnostics...\n"));
+        await (0, dependencies_js_1.ensureNode)(22);
+        await (0, dependencies_js_1.ensureGit)();
+        await (0, dependencies_js_1.ensureGitHubCLI)();
+        await (0, dependencies_js_1.ensureJava)();
+        const sdkPath = await (0, dependencies_js_1.ensureAndroidSdk)();
+        console.log(chalk_1.default.green("\nAll dependency checks passed!"));
+        if (sdkPath) {
+            console.log(chalk_1.default.gray(`Android SDK Path: ${sdkPath}`));
+        }
+    }
+    catch (err) {
+        console.error(chalk_1.default.red("\nDiagnostics failed!"));
+        console.error(err);
+        process.exit(1);
+    }
+}

package/dist/commands/sign.d.ts

@@ -0,0 +1,10 @@
+export interface SignCommandOptions {
+    file?: string;
+    keystore?: string;
+    alias?: string;
+    storepass?: string;
+    keypass?: string;
+    verify?: boolean;
+}
+export declare function findLatestArtifact(extFilter?: string[]): Promise<string | null>;
+export declare function signCommand(fileArg?: string, options?: SignCommandOptions): Promise<void>;