pakstr 0.7.0 → 0.8.1

package/android-template/app/build.gradle.kts

@@ -1,5 +1,4 @@
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
-import java.util.Properties
 import java.io.File
 
 plugins {
@@ -7,49 +6,32 @@ plugins {
     alias(libs.plugins.kotlin.compose)
 }
 
-val keystoreProperties =
-
-    Properties()
-
-val keystorePath =
-    providers.gradleProperty(
-        "releaseKeystoreConfig"
-    ).orNull
-
-val keystorePropertiesFile =
-    keystorePath?.let { rootProject.file(it) }
-if (keystorePropertiesFile?.exists() == true) {
-
-    keystorePropertiesFile.inputStream()
-        .use {
-            keystoreProperties.load(it)
-        }
+val releaseRequested = gradle.startParameter.taskNames.any {
+    it.contains("release", ignoreCase = true)
 }
 
+fun requireReleaseSigningValue(name: String): String =
+    System.getenv(name)
+        ?.takeIf { it.isNotEmpty() }
+        ?: throw GradleException("Missing required release signing environment variable: $name")
+
 android {
     namespace = "com.pakstr.app"
     compileSdk = 36
 
     signingConfigs {
-
         create("release") {
-
-            if (keystorePropertiesFile?.exists() == true) {
-
-                storeFile =
-                    File(
-                        keystorePropertiesFile.parentFile,
-                        keystoreProperties["storeFile"] as String
-                    )
-
-                storePassword =
-                    keystoreProperties["storePassword"] as String
-
-                keyAlias =
-                    keystoreProperties["keyAlias"] as String
-
-                keyPassword =
-                    keystoreProperties["keyPassword"] as String
+            if (releaseRequested) {
+                val keystorePath = requireReleaseSigningValue("PAKSTR_ANDROID_KEYSTORE_PATH")
+                val keystoreFile = File(keystorePath)
+                if (!keystoreFile.isFile) {
+                    throw GradleException("Release signing keystore path is not a file")
+                }
+
+                storeFile = keystoreFile
+                storePassword = requireReleaseSigningValue("PAKSTR_ANDROID_KEYSTORE_PASSWORD")
+                keyAlias = requireReleaseSigningValue("PAKSTR_ANDROID_KEY_ALIAS")
+                keyPassword = requireReleaseSigningValue("PAKSTR_ANDROID_KEY_PASSWORD")
             }
         }
     }
@@ -65,25 +47,22 @@ android {
     }
 
     buildTypes {
-
         debug {
             applicationIdSuffix = ".debug"
             versionNameSuffix = "-debug"
         }
 
         release {
-            signingConfig =
-                signingConfigs.getByName("release")
+            signingConfig = signingConfigs.getByName("release")
             isMinifyEnabled = true
             isShrinkResources = true
             proguardFiles(
-                getDefaultProguardFile(
-                    "proguard-android-optimize.txt"
-                ),
+                getDefaultProguardFile("proguard-android-optimize.txt"),
                 "proguard-rules.pro"
             )
         }
     }
+
     compileOptions {
         sourceCompatibility = JavaVersion.VERSION_17
         targetCompatibility = JavaVersion.VERSION_17
@@ -94,6 +73,7 @@ android {
         buildConfig = true
     }
 }
+
 tasks.withType<KotlinCompile>()
     .configureEach {
         compilerOptions {
@@ -121,9 +101,7 @@ dependencies {
     debugImplementation(libs.androidx.compose.ui.test.manifest)
     implementation(libs.nanohttpd)
     implementation(libs.androidx.appcompat)
-
     implementation(libs.material)
     implementation(libs.androidx.core.splashscreen)
-
     implementation("org.bouncycastle:bcprov-jdk18on:1.78.1")
-}
+}

package/android-template/gradle.properties

@@ -12,5 +12,4 @@ org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
 # https://developer.android.com/r/tools/gradle-multi-project-decoupled-projects
 # org.gradle.parallel=true
 # Kotlin code style for this project: "official" or "obsolete":
-kotlin.code.style=official
-releaseKeystoreConfig=../../../keystore.properties
+kotlin.code.style=official

package/dist/android/branding.js

@@ -4,20 +4,26 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.patchAppName = patchAppName;
-exports.patchPackageName = patchPackageName;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 function patchAppName(androidRoot, appName) {
     const stringsPath = path_1.default.join(androidRoot, "app", "src", "main", "res", "values", "strings.xml");
     let xml = fs_1.default.readFileSync(stringsPath, "utf8");
-    xml = xml.replace(/<string name="app_name">.*?<\/string>/, `<string name="app_name">${appName}</string>`);
+    const appNamePattern = /<string\s+name="app_name"[^>]*>[\s\S]*?<\/string>/g;
+    const matches = [...xml.matchAll(appNamePattern)];
+    if (matches.length !== 1) {
+        throw new Error(`Expected exactly one app_name string resource, found ${matches.length}`);
+    }
+    appNamePattern.lastIndex = 0;
+    xml = xml.replace(appNamePattern, `<string name="app_name">${escapeXmlText(appName)}</string>`);
     fs_1.default.writeFileSync(stringsPath, xml);
     console.log("✅ App name:", appName);
 }
-function patchPackageName(androidRoot, packageName) {
-    const gradlePath = path_1.default.join(androidRoot, "app", "build.gradle.kts");
-    let gradle = fs_1.default.readFileSync(gradlePath, "utf8");
-    gradle = gradle.replace(/applicationId\s*=\s*"[^"]+"/, `applicationId = "${packageName}"`);
-    fs_1.default.writeFileSync(gradlePath, gradle);
-    console.log("✅ ApplicationId:", packageName);
+function escapeXmlText(value) {
+    return value
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&apos;");
 }

package/dist/android/generatedProjectVerification.js

@@ -0,0 +1,95 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyGeneratedAndroidProject = verifyGeneratedAndroidProject;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const gradle_1 = require("./gradle");
+const INTERNAL_NAMESPACE = "com.pakstr.app";
+const INTERNAL_PACKAGE_PATTERN = /^com\.pakstr\.app(?:\.[A-Za-z_][A-Za-z0-9_]*)*$/;
+const SOURCE_EXTENSIONS = new Set([".kt", ".java"]);
+function verifyGeneratedAndroidProject(androidRoot, expected) {
+    const gradlePath = path_1.default.join(androidRoot, "app", "build.gradle.kts");
+    const gradle = (0, gradle_1.readAndroidGradleMetadata)(gradlePath);
+    assertEqual("applicationId", gradle.applicationId, expected.applicationId);
+    assertEqual("versionCode", gradle.versionCode, expected.versionCode);
+    assertEqual("versionName", gradle.versionName, expected.versionName);
+    assertEqual("namespace", gradle.namespace, INTERNAL_NAMESPACE);
+    const javaRoot = path_1.default.join(androidRoot, "app", "src", "main", "java");
+    const sourceRoot = path_1.default.join(javaRoot, "com", "pakstr", "app");
+    if (!fs_1.default.existsSync(sourceRoot) || !fs_1.default.lstatSync(sourceRoot).isDirectory()) {
+        throw new Error(`Expected Pakstr source root is missing: ${sourceRoot}`);
+    }
+    const sourceFiles = collectSourceFiles(javaRoot);
+    if (!sourceFiles.length) {
+        throw new Error(`No Kotlin or Java sources found under ${sourceRoot}`);
+    }
+    for (const sourceFile of sourceFiles) {
+        const declaration = readPackageDeclaration(sourceFile);
+        if (!INTERNAL_PACKAGE_PATTERN.test(declaration)) {
+            throw new Error(`Source package must remain ${INTERNAL_NAMESPACE} or a subpackage: ${sourceFile}`);
+        }
+        if (expected.applicationId !== INTERNAL_NAMESPACE &&
+            (declaration === expected.applicationId ||
+                declaration.startsWith(`${expected.applicationId}.`))) {
+            throw new Error(`Customer applicationId must not be used as a source package: ${sourceFile}`);
+        }
+    }
+    const stringsPath = path_1.default.join(androidRoot, "app", "src", "main", "res", "values", "strings.xml");
+    const appLabel = readSingleAppLabel(stringsPath);
+    assertEqual("app label", decodeXmlText(appLabel), expected.appLabel);
+    return {
+        applicationId: gradle.applicationId,
+        namespace: INTERNAL_NAMESPACE,
+        versionCode: gradle.versionCode,
+        versionName: gradle.versionName,
+        appLabel: expected.appLabel,
+        sourceFilesChecked: sourceFiles.length,
+    };
+}
+function collectSourceFiles(root) {
+    const result = [];
+    for (const entry of fs_1.default.readdirSync(root, { withFileTypes: true })) {
+        const entryPath = path_1.default.join(root, entry.name);
+        if (entry.isDirectory()) {
+            result.push(...collectSourceFiles(entryPath));
+        }
+        else if (SOURCE_EXTENSIONS.has(path_1.default.extname(entry.name))) {
+            result.push(entryPath);
+        }
+    }
+    return result;
+}
+function readPackageDeclaration(sourceFile) {
+    const content = fs_1.default.readFileSync(sourceFile, "utf8");
+    const matches = [...content.matchAll(/^\s*package\s+([A-Za-z_][\w.]*)/gm)];
+    if (matches.length !== 1 || !matches[0][1]) {
+        throw new Error(`Expected exactly one package declaration in source file: ${sourceFile}`);
+    }
+    return matches[0][1];
+}
+function readSingleAppLabel(stringsPath) {
+    const xml = fs_1.default.readFileSync(stringsPath, "utf8");
+    const matches = [
+        ...xml.matchAll(/<string\s+name="app_name"[^>]*>([\s\S]*?)<\/string>/g),
+    ];
+    if (matches.length !== 1 || matches[0][1] === undefined) {
+        throw new Error(`Expected exactly one app_name string resource, found ${matches.length}`);
+    }
+    return matches[0][1];
+}
+function decodeXmlText(value) {
+    return value
+        .replaceAll("&lt;", "<")
+        .replaceAll("&gt;", ">")
+        .replaceAll("&quot;", '"')
+        .replaceAll("&apos;", "'")
+        .replaceAll("&amp;", "&");
+}
+function assertEqual(field, actual, expected) {
+    if (actual !== expected) {
+        throw new Error(`Generated Android project ${field} mismatch: expected ${expected}, received ${actual}`);
+    }
+}

package/dist/android/gradle.js

@@ -4,14 +4,69 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.patchGradle = patchGradle;
+exports.readAndroidGradleMetadata = readAndroidGradleMetadata;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const ASSIGNMENTS = {
+    applicationId: /\bapplicationId\s*=\s*"([^"]*)"/g,
+    namespace: /\bnamespace\s*=\s*"([^"]*)"/g,
+    versionCode: /\bversionCode\s*=\s*(\d+)/g,
+    versionName: /\bversionName\s*=\s*"([^"]*)"/g,
+};
 function patchGradle(androidRoot, manifest) {
-    const gradlePath = path_1.default.join(androidRoot, "app/build.gradle.kts");
-    let content = fs_1.default.readFileSync(gradlePath, "utf-8");
-    content = content.replace(/applicationId\s+".*"/, `applicationId "${manifest.appId}"`);
-    content = content.replace(/versionCode\s+\d+/, `versionCode ${manifest.versionCode}`);
-    content = content.replace(/versionName\s+".*"/, `versionName "${manifest.versionName}"`);
+    const gradlePath = path_1.default.join(androidRoot, "app", "build.gradle.kts");
+    let content = fs_1.default.readFileSync(gradlePath, "utf8");
+    content = replaceSingleAssignment(content, "applicationId", ASSIGNMENTS.applicationId, `applicationId = ${quoteKotlinString(manifest.appId)}`);
+    content = replaceSingleAssignment(content, "versionCode", ASSIGNMENTS.versionCode, `versionCode = ${manifest.versionCode}`);
+    content = replaceSingleAssignment(content, "versionName", ASSIGNMENTS.versionName, `versionName = ${quoteKotlinString(manifest.versionName)}`);
     fs_1.default.writeFileSync(gradlePath, content);
-    console.log("⚙️ Gradle patched");
+    const metadata = readAndroidGradleMetadata(gradlePath);
+    if (metadata.applicationId !== manifest.appId) {
+        throw new Error("Generated Gradle applicationId does not match manifest.appId");
+    }
+    if (metadata.versionCode !== manifest.versionCode) {
+        throw new Error("Generated Gradle versionCode does not match manifest.versionCode");
+    }
+    if (metadata.versionName !== manifest.versionName) {
+        throw new Error("Generated Gradle versionName does not match manifest.versionName");
+    }
+    console.log("⚙️ Gradle identity and version patched");
+    return metadata;
+}
+function readAndroidGradleMetadata(gradlePath) {
+    const content = fs_1.default.readFileSync(gradlePath, "utf8");
+    return {
+        applicationId: readSingleAssignment(content, "applicationId", ASSIGNMENTS.applicationId),
+        namespace: readSingleAssignment(content, "namespace", ASSIGNMENTS.namespace),
+        versionCode: Number(readSingleAssignment(content, "versionCode", ASSIGNMENTS.versionCode)),
+        versionName: readSingleAssignment(content, "versionName", ASSIGNMENTS.versionName),
+    };
+}
+function replaceSingleAssignment(content, field, pattern, replacement) {
+    requireSingleMatch(content, field, pattern);
+    pattern.lastIndex = 0;
+    return content.replace(pattern, replacement);
+}
+function readSingleAssignment(content, field, pattern) {
+    requireSingleMatch(content, field, pattern);
+    pattern.lastIndex = 0;
+    const match = pattern.exec(content);
+    if (!match?.[1]) {
+        throw new Error(`Unable to read Gradle ${field} assignment`);
+    }
+    return match[1];
+}
+function requireSingleMatch(content, field, pattern) {
+    pattern.lastIndex = 0;
+    const matches = [...content.matchAll(pattern)];
+    pattern.lastIndex = 0;
+    if (matches.length !== 1) {
+        throw new Error(`Expected exactly one Kotlin DSL ${field} assignment, found ${matches.length}`);
+    }
+}
+function quoteKotlinString(value) {
+    if (/[\r\n"\\]/.test(value)) {
+        throw new Error("Gradle string values must not contain line breaks, quotes, or backslashes");
+    }
+    return `"${value}"`;
 }

package/dist/android/releaseVerification.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyReleaseApk = verifyReleaseApk;
+exports.parseApkSignerFingerprints = parseApkSignerFingerprints;
+exports.parseKeystoreFingerprints = parseKeystoreFingerprints;
+exports.parseAaptBadging = parseAaptBadging;
+const crypto_1 = require("crypto");
+const releaseSigning_1 = require("../core/releaseSigning");
+function verifyReleaseApk(input) {
+    const signerResult = input.executor.run("apksigner", [
+        "verify",
+        "--print-certs",
+        input.artifactPath,
+    ]);
+    const signerFingerprints = parseApkSignerFingerprints(signerResult.stdout);
+    if (signerFingerprints.length !== 1) {
+        throw new Error(`Release APK must have exactly one current signer; found ${signerFingerprints.length}`);
+    }
+    const keytoolEnv = {
+        [releaseSigning_1.PUBLIC_SIGNING_ENV.keystorePassword]: input.signing.storePassword,
+    };
+    const keytoolResult = input.executor.run("keytool", [
+        "-list",
+        "-rfc",
+        "-keystore",
+        input.toolKeystorePath ?? input.signing.keystorePath,
+        "-storepass:env",
+        releaseSigning_1.PUBLIC_SIGNING_ENV.keystorePassword,
+    ], keytoolEnv);
+    const keystoreFingerprints = parseKeystoreFingerprints(keytoolResult.stdout);
+    const matchingEntries = keystoreFingerprints.filter(fingerprint => fingerprint === signerFingerprints[0]);
+    if (matchingEntries.length !== 1) {
+        throw new Error(`Release APK signer must match exactly one certificate in the supplied keystore; found ${matchingEntries.length}`);
+    }
+    const analyzerMetadata = {
+        applicationId: readAnalyzerValue(input, "application-id"),
+        versionCode: parseVersionCode(readAnalyzerValue(input, "version-code")),
+        versionName: readAnalyzerValue(input, "version-name"),
+    };
+    const badging = parseAaptBadging(input.executor.run("aapt", ["dump", "badging", input.artifactPath]).stdout);
+    assertMetadataField("Application ID", analyzerMetadata.applicationId, input.expectedMetadata.applicationId);
+    assertMetadataField("versionCode", analyzerMetadata.versionCode, input.expectedMetadata.versionCode);
+    assertMetadataField("versionName", analyzerMetadata.versionName, input.expectedMetadata.versionName);
+    assertMetadataField("aapt Application ID", badging.applicationId, analyzerMetadata.applicationId);
+    assertMetadataField("aapt versionCode", badging.versionCode, analyzerMetadata.versionCode);
+    assertMetadataField("aapt versionName", badging.versionName, analyzerMetadata.versionName);
+    assertMetadataField("app label", badging.appLabel, input.expectedMetadata.appLabel);
+    return {
+        signatureVerified: true,
+        signerMatched: true,
+        expectedMetadata: input.expectedMetadata,
+        actualMetadata: {
+            applicationId: analyzerMetadata.applicationId,
+            versionCode: analyzerMetadata.versionCode,
+            versionName: analyzerMetadata.versionName,
+            appLabel: badging.appLabel,
+        },
+        tools: {
+            signature: "apksigner",
+            signer: "keytool",
+            manifest: "apkanalyzer",
+            badging: "aapt",
+        },
+    };
+}
+function parseApkSignerFingerprints(output) {
+    const fingerprints = output
+        .split(/\r?\n/)
+        .map(line => line.match(/Signer #\d+ certificate SHA-256 digest:\s*([0-9a-fA-F]+)/)?.[1])
+        .filter((value) => value !== undefined)
+        .map(normalizeFingerprint);
+    return [...new Set(fingerprints)];
+}
+function parseKeystoreFingerprints(output) {
+    const certificates = output.match(/-----BEGIN CERTIFICATE-----[\s\S]+?-----END CERTIFICATE-----/g);
+    if (!certificates?.length) {
+        throw new Error("No certificate-bearing entries found in supplied keystore");
+    }
+    return certificates.map(pem => {
+        const certificate = new crypto_1.X509Certificate(pem);
+        return (0, crypto_1.createHash)("sha256").update(certificate.raw).digest("hex");
+    });
+}
+function parseAaptBadging(output) {
+    const lines = output.split(/\r?\n/);
+    const packageLines = lines.filter(line => line.startsWith("package: "));
+    const labelLines = lines.filter(line => line.startsWith("application-label:"));
+    if (packageLines.length !== 1) {
+        throw new Error(`Expected exactly one aapt package line, found ${packageLines.length}`);
+    }
+    if (labelLines.length !== 1) {
+        throw new Error(`Expected exactly one default aapt application label, found ${labelLines.length}`);
+    }
+    const packageLine = packageLines[0];
+    const applicationId = readAaptAttribute(packageLine, "name");
+    const versionCode = parseVersionCode(readAaptAttribute(packageLine, "versionCode"));
+    const versionName = readAaptAttribute(packageLine, "versionName");
+    const appLabel = parseQuotedAaptValue(labelLines[0], "application-label");
+    return {
+        applicationId,
+        versionCode,
+        versionName,
+        appLabel,
+    };
+}
+function readAnalyzerValue(input, verb) {
+    const result = input.executor.run("apkanalyzer", [
+        "manifest",
+        verb,
+        input.artifactPath,
+    ]);
+    const values = result.stdout
+        .split(/\r?\n/)
+        .map(value => value.trim())
+        .filter(Boolean);
+    if (values.length !== 1) {
+        throw new Error(`Unable to derive one unambiguous ${verb} from release APK`);
+    }
+    return values[0];
+}
+function parseQuotedAaptValue(line, field) {
+    const pattern = new RegExp(`^${field}:'((?:\\\\.|[^'])*)'$`);
+    const match = pattern.exec(line);
+    if (!match || match[1] === undefined) {
+        throw new Error(`Unable to derive one unambiguous aapt ${field}`);
+    }
+    return decodeAaptEscapes(match[1]);
+}
+function readAaptAttribute(line, name) {
+    const pattern = new RegExp(`${name}='((?:\\\\.|[^'])*)'`);
+    const match = pattern.exec(line);
+    if (!match || match[1] === undefined) {
+        throw new Error(`Unable to derive one unambiguous aapt ${name}`);
+    }
+    return decodeAaptEscapes(match[1]);
+}
+function decodeAaptEscapes(value) {
+    return value.replace(/\\(.)/gs, (_match, escaped) => {
+        switch (escaped) {
+            case "n":
+                return "\n";
+            case "r":
+                return "\r";
+            case "t":
+                return "\t";
+            default:
+                return escaped;
+        }
+    });
+}
+function parseVersionCode(value) {
+    if (!/^\d+$/.test(value)) {
+        throw new Error(`APK versionCode is not an integer: ${value}`);
+    }
+    return Number(value);
+}
+function assertMetadataField(field, actual, expected) {
+    if (actual !== expected) {
+        throw new Error(`Release APK ${field} mismatch: expected ${expected}, received ${actual}`);
+    }
+}
+function normalizeFingerprint(value) {
+    return value.replace(/[^0-9a-fA-F]/g, "").toLowerCase();
+}

package/dist/android/releaseWorkspace.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReleaseWorkspace = createReleaseWorkspace;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const template_1 = require("./template");
+function createReleaseWorkspace(templateRoot) {
+    const workspaceRoot = path_1.default.join((0, template_1.getCacheDir)(), "workspaces");
+    fs_1.default.mkdirSync(workspaceRoot, { recursive: true, mode: 0o700 });
+    const workspaceParent = fs_1.default.mkdtempSync(path_1.default.join(workspaceRoot, "pakstr-release-workspace-"));
+    const androidRoot = path_1.default.join(workspaceParent, "android");
+    let cleaned = false;
+    try {
+        fs_1.default.chmodSync(workspaceParent, 0o700);
+        fs_1.default.cpSync(templateRoot, androidRoot, { recursive: true });
+        const gradlewPath = path_1.default.join(androidRoot, "gradlew");
+        if (fs_1.default.existsSync(gradlewPath)) {
+            fs_1.default.chmodSync(gradlewPath, 0o755);
+        }
+    }
+    catch (error) {
+        fs_1.default.rmSync(workspaceParent, { recursive: true, force: true });
+        throw error;
+    }
+    return {
+        androidRoot,
+        cleanup() {
+            if (cleaned)
+                return;
+            fs_1.default.rmSync(workspaceParent, {
+                recursive: true,
+                force: true,
+                maxRetries: 2,
+            });
+            if (fs_1.default.existsSync(workspaceParent)) {
+                throw new Error(`Failed to remove temporary release workspace: ${workspaceParent}`);
+            }
+            cleaned = true;
+        },
+    };
+}

package/dist/android/template.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCacheDir = getCacheDir;
 exports.ensureTemplate = ensureTemplate;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
@@ -54,10 +55,14 @@ function fixGradlewPermissions(root) {
 // -----------------------------
 function createLocalProperties(root) {
     const sdkPath = process.env.ANDROID_HOME ??
+        process.env.ANDROID_SDK_ROOT ??
         path_1.default.join(os_1.default.homedir(), "Library", "Android", "sdk");
-    const content = `sdk.dir=${sdkPath}\n`;
     const file = path_1.default.join(root, "local.properties");
-    fs_1.default.writeFileSync(file, content);
+    if (!fs_1.default.existsSync(sdkPath)) {
+        fs_1.default.rmSync(file, { force: true });
+        return;
+    }
+    fs_1.default.writeFileSync(file, `sdk.dir=${sdkPath}\n`);
     console.log("📍 local.properties created:", sdkPath);
 }
 async function ensureTemplate() {