pakstr 0.8.0 → 0.8.2

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

@@ -3,6 +3,7 @@ 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) {
@@ -23,40 +24,42 @@ function verifyReleaseApk(input) {
         "-rfc",
         "-keystore",
         input.toolKeystorePath ?? input.signing.keystorePath,
-        `-storepass:env`,
+        "-storepass:env",
         releaseSigning_1.PUBLIC_SIGNING_ENV.keystorePassword,
     ], keytoolEnv);
     const keystoreFingerprints = parseKeystoreFingerprints(keytoolResult.stdout);
-    const signerFingerprint = signerFingerprints[0];
-    const matchingEntries = keystoreFingerprints.filter(fingerprint => fingerprint === signerFingerprint);
+    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 identityResult = input.executor.run("apkanalyzer", [
-        "manifest",
-        "application-id",
-        input.artifactPath,
-    ]);
-    const applicationIds = identityResult.stdout
-        .split(/\r?\n/)
-        .map(value => value.trim())
-        .filter(Boolean);
-    if (applicationIds.length !== 1) {
-        throw new Error("Unable to derive one unambiguous Application ID from release APK");
-    }
-    const actualApplicationId = applicationIds[0];
-    if (actualApplicationId !== input.expectedApplicationId) {
-        throw new Error(`Release APK Application ID mismatch: expected ${input.expectedApplicationId}, received ${actualApplicationId}`);
-    }
+    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,
-        expectedApplicationId: input.expectedApplicationId,
-        actualApplicationId,
+        expectedMetadata: input.expectedMetadata,
+        actualMetadata: {
+            applicationId: analyzerMetadata.applicationId,
+            versionCode: analyzerMetadata.versionCode,
+            versionName: analyzerMetadata.versionName,
+            appLabel: badging.appLabel,
+        },
         tools: {
             signature: "apksigner",
             signer: "keytool",
-            identity: "apkanalyzer",
+            manifest: "apkanalyzer",
+            badging: "aapt",
         },
     };
 }
@@ -78,6 +81,84 @@ function parseKeystoreFingerprints(output) {
         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/commands/build.js

@@ -7,6 +7,7 @@ exports.buildCommand = buildCommand;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const child_process_1 = require("child_process");
+const generatedProjectVerification_1 = require("../android/generatedProjectVerification");
 const gradle_1 = require("../android/gradle");
 const branding_1 = require("../android/branding");
 const icon_1 = require("../android/icon");
@@ -14,7 +15,6 @@ const permissions_1 = require("../android/permissions");
 const releaseWorkspace_1 = require("../android/releaseWorkspace");
 const splash_1 = require("../android/splash");
 const template_1 = require("../android/template");
-const version_1 = require("../android/version");
 const buildContext_1 = require("../core/buildContext");
 const config_1 = require("../core/config");
 const releaseSigning_1 = require("../core/releaseSigning");
@@ -26,7 +26,7 @@ async function buildCommand(args) {
     const config = (0, config_1.loadConfig)(process.cwd());
     const manifest = ctx.manifest;
     const mode = ctx.mode;
-    const appName = manifest?.app?.name || manifest?.appName || "Pakstr App";
+    const appName = manifest.appName;
     const finalPath = path_1.default.resolve(ctx.out);
     console.log("\n🚀 Pakstr CLI");
     console.log("📦 App:", appName);
@@ -60,7 +60,12 @@ async function buildCommand(args) {
         const result = await (0, createRunner_1.createRunner)(config).build({
             androidRoot,
             mode,
-            expectedApplicationId: manifest.appId,
+            expectedMetadata: {
+                applicationId: manifest.appId,
+                versionCode: manifest.versionCode,
+                versionName: manifest.versionName,
+                appLabel: appName,
+            },
             signing,
         });
         if (mode === "release" && !result.verification) {
@@ -115,8 +120,6 @@ async function prepareAndroidProject(androidRoot, distPath, manifest, appName) {
     (0, runtimeConfig_1.generateRuntimeConfig)(assetsTarget, manifest);
     (0, gradle_1.patchGradle)(androidRoot, manifest);
     (0, branding_1.patchAppName)(androidRoot, appName);
-    (0, branding_1.patchPackageName)(androidRoot, manifest.appId);
-    (0, version_1.patchVersion)(androidRoot, manifest.versionCode, manifest.versionName);
     if (manifest.ui?.icon) {
         await (0, icon_1.patchIcon)(androidRoot, manifest.ui.icon, manifest.backgroundColor ?? "#FFFFFF");
     }
@@ -124,6 +127,12 @@ async function prepareAndroidProject(androidRoot, distPath, manifest, appName) {
         await (0, splash_1.patchSplash)(androidRoot, manifest.ui.splash.image, manifest.ui.splash.background ?? "#FFFFFF");
     }
     (0, permissions_1.patchPermissions)(androidRoot, manifest);
+    (0, generatedProjectVerification_1.verifyGeneratedAndroidProject)(androidRoot, {
+        applicationId: manifest.appId,
+        versionCode: manifest.versionCode,
+        versionName: manifest.versionName,
+        appLabel: appName,
+    });
 }
 function validateOutputParent(finalPath) {
     const parent = path_1.default.dirname(finalPath);

package/dist/core/manifest.js

@@ -28,10 +28,19 @@ function validateManifest(m) {
     }
     if (!m.appName)
         throw new Error("❌ appName is required");
+    if (/[\r\n]/.test(m.appName)) {
+        throw new Error("❌ appName must not contain line breaks");
+    }
     if (!m.versionName)
         throw new Error("❌ versionName is required");
+    if (/[\r\n"\\]/.test(m.versionName)) {
+        throw new Error("❌ versionName must not contain line breaks, quotes, or backslashes");
+    }
     if (m.versionCode === undefined)
         throw new Error("❌ versionCode is required");
+    if (!Number.isInteger(m.versionCode) || m.versionCode <= 0) {
+        throw new Error("❌ versionCode must be a positive integer");
+    }
     if (m.ui?.splash && !m.ui.splash.image) {
         throw new Error("❌ splash.image is required");
     }

package/dist/runners/DockerGradleRunner.js

@@ -106,7 +106,7 @@ class DockerGradleRunner {
         });
         const verification = (0, releaseVerification_1.verifyReleaseApk)({
             artifactPath: CONTAINER_RELEASE_APK,
-            expectedApplicationId: request.expectedApplicationId,
+            expectedMetadata: request.expectedMetadata,
             signing,
             toolKeystorePath: CONTAINER_KEYSTORE_PATH,
             executor: this.createVerificationExecutor(storage, signing),

package/dist/runners/LocalGradleRunner.js

@@ -37,13 +37,26 @@ class LocalGradleRunner {
             streamOutput: true,
         });
         const artifactPath = requireApk(androidRoot, "release");
-        const executor = createLocalVerificationExecutor(signing);
-        const verification = (0, releaseVerification_1.verifyReleaseApk)({
-            artifactPath,
-            expectedApplicationId: request.expectedApplicationId,
-            signing,
-            executor,
-        });
+        let verification;
+        try {
+            const executor = createLocalVerificationExecutor(signing);
+            verification = (0, releaseVerification_1.verifyReleaseApk)({
+                artifactPath,
+                expectedMetadata: request.expectedMetadata,
+                signing,
+                executor,
+            });
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                error.message.startsWith("Required Android verification tool not found")) {
+                console.warn("⚠️ Local release verification skipped: Android verification tools are missing.");
+                console.warn("ℹ️ Production releases should use CI Docker verification.");
+            }
+            else {
+                throw error;
+            }
+        }
         return { artifactPath, verification };
     }
 }
@@ -67,9 +80,18 @@ function resolveTool(tool, androidHome) {
     if (tool === "keytool")
         return "keytool";
     if (tool === "apkanalyzer") {
-        const analyzer = path_1.default.join(androidHome, "cmdline-tools", "latest", "bin", "apkanalyzer");
-        if (!fs_1.default.existsSync(analyzer)) {
-            throw new Error(`Required Android verification tool not found: ${analyzer}`);
+        const cmdlineTools = path_1.default.join(androidHome, "cmdline-tools");
+        if (!fs_1.default.existsSync(cmdlineTools)) {
+            throw new Error(`Android cmdline-tools directory not found: ${cmdlineTools}`);
+        }
+        const versions = fs_1.default
+            .readdirSync(cmdlineTools)
+            .sort((a, b) => b.localeCompare(a, undefined, { numeric: true }));
+        const analyzer = versions
+            .map(version => path_1.default.join(cmdlineTools, version, "bin", "apkanalyzer"))
+            .find(candidate => fs_1.default.existsSync(candidate));
+        if (!analyzer) {
+            throw new Error(`Required Android verification tool not found under ${cmdlineTools}`);
         }
         return analyzer;
     }
@@ -80,13 +102,14 @@ function resolveTool(tool, androidHome) {
     const versions = fs_1.default
         .readdirSync(buildToolsDir)
         .sort((a, b) => b.localeCompare(a, undefined, { numeric: true }));
-    const signer = versions
-        .map(version => path_1.default.join(buildToolsDir, version, "apksigner"))
+    const executable = tool === "aapt" ? "aapt" : "apksigner";
+    const resolved = versions
+        .map(version => path_1.default.join(buildToolsDir, version, executable))
         .find(candidate => fs_1.default.existsSync(candidate));
-    if (!signer) {
-        throw new Error(`Required Android verification tool apksigner not found under ${buildToolsDir}`);
+    if (!resolved) {
+        throw new Error(`Required Android verification tool ${executable} not found under ${buildToolsDir}`);
     }
-    return signer;
+    return resolved;
 }
 function requireApk(androidRoot, mode) {
     const artifactPath = path_1.default.join(androidRoot, "app", "build", "outputs", "apk", mode, `app-${mode}.apk`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pakstr",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "CLI for packaging Nostr web apps into Android APKs",
   "type": "commonjs",
   "main": "dist/index.js",

package/dist/android/version.js

@@ -1,16 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.patchVersion = patchVersion;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-function patchVersion(androidRoot, versionCode, versionName) {
-    const gradlePath = path_1.default.join(androidRoot, "app", "build.gradle.kts");
-    let gradle = fs_1.default.readFileSync(gradlePath, "utf8");
-    gradle = gradle.replace(/versionCode\s*=\s*[^\r\n]+/, `versionCode = ${versionCode}`);
-    gradle = gradle.replace(/versionName\s*=\s*"[^"]+"/, `versionName = "${versionName}"`);
-    fs_1.default.writeFileSync(gradlePath, gradle);
-    console.log("✅ Version patched:", versionCode, versionName);
-}