pakstr 0.0.1 → 0.0.3

package/dist/android/icon.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchIcon = patchIcon;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const sharp_1 = __importDefault(require("sharp"));
+async function patchIcon(androidRoot, iconPath, backgroundColor = "#FFFFFF") {
+    if (!iconPath) {
+        console.log("ℹ️ No icon provided");
+        return;
+    }
+    const absoluteIconPath = path_1.default.resolve(process.cwd(), iconPath);
+    if (!fs_1.default.existsSync(absoluteIconPath)) {
+        throw new Error(`❌ Icon not found: ${absoluteIconPath}`);
+    }
+    const resPath = path_1.default.join(androidRoot, "app/src/main/res");
+    //
+    // 1. LEGACY ICONS
+    //
+    const sizes = {
+        "mipmap-mdpi": 48,
+        "mipmap-hdpi": 72,
+        "mipmap-xhdpi": 96,
+        "mipmap-xxhdpi": 144,
+        "mipmap-xxxhdpi": 192,
+    };
+    for (const folder of Object.keys(sizes)) {
+        const dir = path_1.default.join(resPath, folder);
+        fs_1.default.mkdirSync(dir, {
+            recursive: true,
+        });
+        await (0, sharp_1.default)(absoluteIconPath)
+            .resize(sizes[folder], sizes[folder], {
+            fit: "contain",
+        })
+            .webp()
+            .toFile(path_1.default.join(dir, "ic_launcher.webp"));
+        await (0, sharp_1.default)(absoluteIconPath)
+            .resize(sizes[folder], sizes[folder], {
+            fit: "contain",
+        })
+            .webp()
+            .toFile(path_1.default.join(dir, "ic_launcher_round.webp"));
+        console.log(`🖼️ Generated ${folder}`);
+    }
+    //
+    // 2. ADAPTIVE FOREGROUND
+    //
+    const drawablePath = path_1.default.join(resPath, "drawable");
+    fs_1.default.mkdirSync(drawablePath, {
+        recursive: true,
+    });
+    await (0, sharp_1.default)(absoluteIconPath)
+        .resize(432, 432, {
+        fit: "contain",
+        background: {
+            r: 0,
+            g: 0,
+            b: 0,
+            alpha: 0,
+        },
+    })
+        .webp()
+        .toFile(path_1.default.join(drawablePath, "ic_launcher_foreground.webp"));
+    console.log("🖼️ Generated adaptive foreground");
+    //
+    // 3. REMOVE OLD VECTOR FOREGROUND
+    //
+    const oldXml = path_1.default.join(drawablePath, "ic_launcher_foreground.xml");
+    if (fs_1.default.existsSync(oldXml)) {
+        fs_1.default.unlinkSync(oldXml);
+    }
+    //
+    // 4. BACKGROUND COLOR
+    //
+    const valuesPath = path_1.default.join(resPath, "values");
+    fs_1.default.mkdirSync(valuesPath, {
+        recursive: true,
+    });
+    fs_1.default.writeFileSync(path_1.default.join(valuesPath, "launcher_colors.xml"), `<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="ic_launcher_background">${backgroundColor}</color>
+</resources>`);
+    //
+    // 5. ADAPTIVE XML
+    //
+    const adaptiveDir = path_1.default.join(resPath, "mipmap-anydpi-v26");
+    fs_1.default.mkdirSync(adaptiveDir, {
+        recursive: true,
+    });
+    const adaptiveXml = `<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <background android:drawable="@color/ic_launcher_background"/>
+
+    <foreground android:drawable="@drawable/ic_launcher_foreground"/>
+
+</adaptive-icon>`;
+    fs_1.default.writeFileSync(path_1.default.join(adaptiveDir, "ic_launcher.xml"), adaptiveXml);
+    fs_1.default.writeFileSync(path_1.default.join(adaptiveDir, "ic_launcher_round.xml"), adaptiveXml);
+    console.log("✅ Adaptive icon patched");
+}

package/dist/android/permissions.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchPermissions = patchPermissions;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const permissionMap = {
+    internet: "android.permission.INTERNET",
+    camera: "android.permission.CAMERA",
+    notifications: "android.permission.POST_NOTIFICATIONS",
+};
+function patchPermissions(androidRoot, manifest) {
+    if (!manifest.permissions?.length) {
+        return;
+    }
+    const file = path_1.default.join(androidRoot, "app/src/main/AndroidManifest.xml");
+    let xml = fs_1.default.readFileSync(file, "utf-8");
+    for (const perm of manifest.permissions) {
+        const androidPermission = permissionMap[perm];
+        if (!androidPermission) {
+            console.warn(`⚠️ Unknown permission: ${perm}`);
+            continue;
+        }
+        const line = `<uses-permission android:name="${androidPermission}"/>`;
+        if (!xml.includes(line)) {
+            xml = xml.replace("<manifest", `<manifest\n    ${line}`);
+        }
+    }
+    fs_1.default.writeFileSync(file, xml);
+    console.log("🔐 Permissions patched");
+}

package/dist/android/splash.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchSplash = patchSplash;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const sharp_1 = __importDefault(require("sharp"));
+async function patchSplash(androidRoot, splashPath, backgroundColor) {
+    if (!splashPath) {
+        console.log("ℹ️ No splash provided");
+        return;
+    }
+    const absolutePath = path_1.default.resolve(splashPath);
+    if (!fs_1.default.existsSync(absolutePath)) {
+        throw new Error(`❌ Splash not found: ${absolutePath}`);
+    }
+    // -----------------------------
+    // GENERATE SPLASH IMAGE
+    // -----------------------------
+    const splashOutput = path_1.default.join(androidRoot, "app/src/main/res/drawable/splash_image.webp");
+    await (0, sharp_1.default)(absolutePath)
+        .resize(512, 512, {
+        fit: "contain",
+    })
+        .webp()
+        .toFile(splashOutput);
+    console.log("🖼️ Generated splash image");
+    // -----------------------------
+    // PATCH COLORS.XML
+    // -----------------------------
+    if (backgroundColor) {
+        const colorsFile = path_1.default.join(androidRoot, "app/src/main/res/values/colors.xml");
+        if (fs_1.default.existsSync(colorsFile)) {
+            let colors = fs_1.default.readFileSync(colorsFile, "utf-8");
+            if (colors.includes("splash_background")) {
+                colors = colors.replace(/<color name="splash_background">.*<\/color>/, `<color name="splash_background">${backgroundColor}</color>`);
+            }
+            else {
+                colors = colors.replace("</resources>", `
+    <color name="splash_background">${backgroundColor}</color>
+  </resources>`);
+            }
+            fs_1.default.writeFileSync(colorsFile, colors);
+            console.log("🎨 Splash background patched");
+        }
+    }
+    // -----------------------------
+    // PATCH THEME
+    // -----------------------------
+    const themeFile = path_1.default.join(androidRoot, "app/src/main/res/values/themes.xml");
+    if (!fs_1.default.existsSync(themeFile)) {
+        console.log("⚠️ Theme file not found, skipping theme patch");
+        return;
+    }
+    let theme = fs_1.default.readFileSync(themeFile, "utf-8");
+    theme = theme.replace("@color/white", "@color/splash_background");
+    theme = theme.replace("@mipmap/ic_launcher", "@drawable/splash_image");
+    fs_1.default.writeFileSync(themeFile, theme);
+    console.log("✅ Splash patched");
+}

package/dist/android/template.js

@@ -0,0 +1,142 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureTemplate = ensureTemplate;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const unzipper_1 = __importDefault(require("unzipper"));
+const TEMPLATE_URL = "https://git.nostrdev.com/stuff/pakstr/archive/main.zip";
+function getCacheDir() {
+    return path_1.default.join(os_1.default.homedir(), ".nostrappshell");
+}
+function getTemplatePath() {
+    return path_1.default.join(getCacheDir(), "android-template");
+}
+// -----------------------------
+// FIND TEMPLATE ROOT (RECURSIVE)
+// -----------------------------
+function findTemplateRoot(dir) {
+    const entries = fs_1.default.readdirSync(dir);
+    for (const e of entries) {
+        const full = path_1.default.join(dir, e);
+        if (!fs_1.default.statSync(full).isDirectory())
+            continue;
+        if (fs_1.default.existsSync(path_1.default.join(full, "app/build.gradle.kts"))) {
+            return full;
+        }
+        const nested = findTemplateRoot(full);
+        if (nested)
+            return nested;
+    }
+    return null;
+}
+// -----------------------------
+// FIX GRADLEW PERMISSIONS
+// -----------------------------
+function fixGradlewPermissions(root) {
+    const possiblePaths = [
+        path_1.default.join(root, "gradlew"),
+        path_1.default.join(root, "app", "gradlew"),
+    ];
+    for (const p of possiblePaths) {
+        if (fs_1.default.existsSync(p)) {
+            fs_1.default.chmodSync(p, 0o755);
+            console.log("🔐 gradlew permission fixed:", p);
+        }
+    }
+}
+// -----------------------------
+// CREATE LOCAL.PROPERTIES
+// -----------------------------
+function createLocalProperties(root) {
+    const sdkPath = process.env.ANDROID_HOME ??
+        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);
+    console.log("📍 local.properties created:", sdkPath);
+}
+async function ensureTemplate() {
+    const cacheDir = getCacheDir();
+    const templatePath = getTemplatePath();
+    const zipPath = path_1.default.join(cacheDir, "template.zip");
+    // -----------------------------
+    // BUNDLED TEMPLATE CHECK
+    // -----------------------------
+    const bundledTemplate = path_1.default.resolve(__dirname, "../../android-template");
+    if (fs_1.default.existsSync(path_1.default.join(bundledTemplate, "settings.gradle.kts"))) {
+        console.log("📦 Using bundled Android template");
+        if (fs_1.default.existsSync(templatePath)) {
+            fs_1.default.rmSync(templatePath, {
+                recursive: true,
+                force: true
+            });
+        }
+        fs_1.default.cpSync(bundledTemplate, templatePath, {
+            recursive: true
+        });
+        fixGradlewPermissions(templatePath);
+        createLocalProperties(templatePath);
+        return templatePath;
+    }
+    // -----------------------------
+    // CACHE CHECK
+    // -----------------------------
+    if (fs_1.default.existsSync(path_1.default.join(templatePath, "settings.gradle.kts"))) {
+        console.log("📦 Using cached Android template");
+        return templatePath;
+    }
+    console.log("📥 Downloading Android template...");
+    fs_1.default.mkdirSync(cacheDir, { recursive: true });
+    // -----------------------------
+    // DOWNLOAD ZIP
+    // -----------------------------
+    const res = await (0, node_fetch_1.default)(TEMPLATE_URL);
+    if (!res.ok || !res.body) {
+        throw new Error("Failed to download template");
+    }
+    const fileStream = fs_1.default.createWriteStream(zipPath);
+    const body = res.body;
+    await new Promise((resolve, reject) => {
+        body.pipe(fileStream);
+        body.on("error", reject);
+        fileStream.on("error", reject);
+        fileStream.on("finish", resolve);
+    });
+    console.log("📦 Extracting template...");
+    // -----------------------------
+    // EXTRACT ZIP
+    // -----------------------------
+    await new Promise((resolve, reject) => {
+        fs_1.default.createReadStream(zipPath)
+            .pipe(unzipper_1.default.Extract({ path: cacheDir }))
+            .on("close", resolve)
+            .on("error", reject);
+    });
+    // -----------------------------
+    // FIND ANDROID ROOT
+    // -----------------------------
+    const extractedPath = findTemplateRoot(cacheDir);
+    if (!extractedPath) {
+        throw new Error("Template extract failed - no valid Android project found");
+    }
+    // -----------------------------
+    // MOVE TO FINAL LOCATION
+    // -----------------------------
+    if (fs_1.default.existsSync(templatePath)) {
+        fs_1.default.rmSync(templatePath, { recursive: true, force: true });
+    }
+    fs_1.default.renameSync(extractedPath, templatePath);
+    fs_1.default.unlinkSync(zipPath);
+    console.log("✅ Template ready at:", templatePath);
+    // -----------------------------
+    // FIX PERMISSIONS (IMPORTANT)
+    // -----------------------------
+    fixGradlewPermissions(templatePath);
+    createLocalProperties(templatePath);
+    return templatePath;
+}

package/dist/android/version.js

@@ -0,0 +1,16 @@
+"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);
+}

package/dist/cli.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCLI = runCLI;
+const build_1 = require("./commands/build");
+const package_json_1 = __importDefault(require("../package.json"));
+async function runCLI(argv) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        printHelp();
+        return;
+    }
+    if (argv.includes("--version") || argv.includes("-v")) {
+        console.log(package_json_1.default.version);
+        return;
+    }
+    const command = argv[0];
+    const subcommand = argv[1];
+    const args = argv.slice(2);
+    if (!command) {
+        printHelp();
+        return;
+    }
+    switch (command) {
+        case "build":
+            if (subcommand === "apk") {
+                console.log("🚀 Running: build apk");
+                return await (0, build_1.buildCommand)(args);
+            }
+            console.error("❌ Missing subcommand. Use: build apk");
+            process.exitCode = 1;
+            return;
+        default:
+            console.error(`❌ Unknown command: ${command}`);
+            printHelp();
+            process.exitCode = 1;
+            return;
+    }
+}
+function printHelp() {
+    console.log(`
+🚀 Pakstr CLI
+
+Usage:
+
+  pakstr build apk --manifest <path> --web <path> --out <path>
+
+Example:
+
+  pakstr build apk \
+    --manifest app.manifest.json \
+    --web ./dist \
+    --out ./build/app.apk
+`);
+}

package/dist/commands/build.js

@@ -0,0 +1,159 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCommand = buildCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const gradle_1 = require("../android/gradle");
+const validateProject_1 = require("../core/validateProject");
+const buildContext_1 = require("../core/buildContext");
+const template_1 = require("../android/template");
+const createRunner_1 = require("../runners/createRunner");
+const config_1 = require("../core/config");
+const branding_1 = require("../android/branding");
+const version_1 = require("../android/version");
+const icon_1 = require("../android/icon");
+const splash_1 = require("../android/splash");
+const permissions_1 = require("../android/permissions");
+async function buildCommand(args) {
+    const ctx = (0, buildContext_1.createBuildContext)(args);
+    const config = (0, config_1.loadConfig)(process.cwd());
+    const manifest = ctx.manifest;
+    console.log("📄 Manifest loaded");
+    const distPath = ctx.dist;
+    const androidRoot = await (0, template_1.ensureTemplate)();
+    const mode = ctx.mode;
+    const apkOutput = ctx.out;
+    const assetsTarget = path_1.default.join(androidRoot, "app/src/main/assets/www");
+    const appName = manifest?.app?.name || manifest?.appName || "Pakstr App";
+    console.log("\n🚀 Pakstr CLI");
+    console.log("📦 App:", appName);
+    console.log("🌐 Web:", distPath);
+    console.log("📱 Out:", apkOutput);
+    console.log("📱 Android:", androidRoot);
+    console.log("🏗️ Builder:", config.builder);
+    console.log("🚀 BUILD MODE:", mode.toUpperCase());
+    // -----------------------------
+    // 1. VALIDATE PROJECT
+    // -----------------------------
+    (0, validateProject_1.validateProject)(distPath, manifest);
+    if (!fs_1.default.existsSync(distPath)) {
+        throw new Error("❌ Web assets not found");
+    }
+    // -----------------------------
+    // 2. COPY WEB → ANDROID ASSETS
+    // -----------------------------
+    console.log("\n📦 Copying web → Android assets...");
+    fs_1.default.rmSync(assetsTarget, {
+        recursive: true,
+        force: true,
+    });
+    fs_1.default.mkdirSync(assetsTarget, {
+        recursive: true,
+    });
+    copyFolder(distPath, assetsTarget);
+    console.log("📦 Web assets copied successfully");
+    // -----------------------------
+    // 3. PATCH ANDROID PROJECT
+    // -----------------------------
+    (0, gradle_1.patchGradle)(androidRoot, manifest);
+    console.log("⚙️ Gradle patched");
+    // -----------------------------
+    // 3.1 PATCH BRANDING
+    // -----------------------------
+    (0, branding_1.patchAppName)(androidRoot, appName);
+    (0, branding_1.patchPackageName)(androidRoot, manifest.appId);
+    (0, version_1.patchVersion)(androidRoot, manifest.versionCode, manifest.versionName);
+    const iconPath = manifest.ui?.icon;
+    if (iconPath) {
+        await (0, icon_1.patchIcon)(androidRoot, iconPath, manifest.backgroundColor ?? "#FFFFFF");
+    }
+    const splash = manifest.ui?.splash;
+    if (splash) {
+        console.log("SPLASH IMAGE:", splash.image);
+        console.log("SPLASH BACKGROUND:", splash.background);
+        await (0, splash_1.patchSplash)(androidRoot, splash.image, splash.background ?? "#FFFFFF");
+    }
+    (0, permissions_1.patchPermissions)(androidRoot, manifest);
+    // -----------------------------
+    // 4. RUN BUILD RUNNER
+    // -----------------------------
+    let apkPath;
+    try {
+        console.log("\n⚙️ Running build runner...");
+        const runner = (0, createRunner_1.createRunner)(config);
+        apkPath = await runner.build(androidRoot, mode);
+        console.log("✅ APK build successful");
+        console.log("\n📦 APK GENERATED:");
+        console.log(apkPath);
+    }
+    catch (err) {
+        console.error("❌ Build failed");
+        console.error(err);
+        throw err;
+    }
+    // -----------------------------
+    // 5. COPY APK TO OUTPUT
+    // -----------------------------
+    const finalPath = path_1.default.resolve(apkOutput);
+    fs_1.default.mkdirSync(path_1.default.dirname(finalPath), {
+        recursive: true,
+    });
+    if (fs_1.default.existsSync(finalPath)) {
+        const stat = fs_1.default.lstatSync(finalPath);
+        if (stat.isDirectory()) {
+            fs_1.default.rmSync(finalPath, {
+                recursive: true,
+                force: true,
+            });
+        }
+    }
+    fs_1.default.copyFileSync(apkPath, finalPath);
+    console.log("\n📦 CLEAN OUTPUT:");
+    console.log(finalPath);
+    openFolder(finalPath);
+    // -----------------------------
+    // 6. FINAL OUTPUT
+    // -----------------------------
+    console.log("\n🚀 BUILD COMPLETE");
+    console.log("App:", appName);
+    console.log("Mode:", mode.toUpperCase());
+}
+// -----------------------------
+// COPY FOLDER
+// -----------------------------
+function copyFolder(src, dest) {
+    const entries = fs_1.default.readdirSync(src, {
+        withFileTypes: true,
+    });
+    for (const entry of entries) {
+        const srcPath = path_1.default.join(src, entry.name);
+        const destPath = path_1.default.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            fs_1.default.mkdirSync(destPath, {
+                recursive: true,
+            });
+            copyFolder(srcPath, destPath);
+        }
+        else {
+            fs_1.default.copyFileSync(srcPath, destPath);
+        }
+    }
+}
+// -----------------------------
+// OPEN FOLDER (macOS)
+// -----------------------------
+function openFolder(filePath) {
+    if (process.platform !== "darwin") {
+        return;
+    }
+    try {
+        (0, child_process_1.execSync)(`open "${path_1.default.dirname(filePath)}"`);
+    }
+    catch {
+        // ignore
+    }
+}

package/dist/config.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEMPLATE_URL = void 0;
+exports.TEMPLATE_URL = "https://git.nostrdev.com/stuff/pakstr/-/archive/main/pakstr-main.zip";

package/dist/core/buildContext.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBuildContext = createBuildContext;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const manifest_1 = require("./manifest");
+// -----------------------------
+// CONFIG LOADER
+// -----------------------------
+function loadConfig() {
+    const configPath = path_1.default.resolve(process.cwd(), "nostr.config.json");
+    if (!fs_1.default.existsSync(configPath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(fs_1.default.readFileSync(configPath, "utf-8"));
+    }
+    catch (e) {
+        throw new Error("❌ Invalid nostr.config.json");
+    }
+}
+function createBuildContext(args) {
+    const getArg = (key) => {
+        const i = args.indexOf(key);
+        return i !== -1 ? args[i + 1] : null;
+    };
+    function resolvePath(p) {
+        if (!p)
+            return null;
+        // absolute path
+        if (path_1.default.isAbsolute(p)) {
+            return p;
+        }
+        // try cwd
+        const cwdPath = path_1.default.resolve(process.cwd(), p);
+        if (fs_1.default.existsSync(cwdPath)) {
+            return cwdPath;
+        }
+        // try one level up (VERY IMPORTANT for your case)
+        const parentPath = path_1.default.resolve(process.cwd(), "..", p);
+        if (fs_1.default.existsSync(parentPath)) {
+            return parentPath;
+        }
+        return cwdPath;
+    }
+    const mode = args.includes("--release") ? "release" : "debug";
+    // -----------------------------
+    // 1. LOAD CONFIG (OPTIONAL)
+    // -----------------------------
+    const config = loadConfig();
+    // -----------------------------
+    // 2. RESOLVE INPUTS (PRIORITY ORDER)
+    // args > config > error
+    // -----------------------------
+    const webRaw = getArg("--web") ?? config?.web;
+    const manifestPathRaw = getArg("--manifest") ?? config?.manifest;
+    const outPathRaw = getArg("--out") ?? config?.out;
+    const web = resolvePath(webRaw);
+    const manifestPath = resolvePath(manifestPathRaw);
+    const outPath = resolvePath(outPathRaw);
+    // -----------------------------
+    // 3. VALIDATION (STRICT)
+    // -----------------------------
+    if (!web) {
+        throw new Error("❌ Missing web path (--web or nostr.config.json)");
+    }
+    if (!manifestPath) {
+        throw new Error("❌ Missing manifest path (--manifest or nostr.config.json)");
+    }
+    if (!fs_1.default.existsSync(web)) {
+        throw new Error(`❌ Web folder not found: ${web}`);
+    }
+    if (!fs_1.default.existsSync(manifestPath)) {
+        throw new Error(`❌ Manifest not found: ${manifestPath}`);
+    }
+    // -----------------------------
+    // 4. LOAD MANIFEST
+    // -----------------------------
+    const manifest = (0, manifest_1.loadManifest)(manifestPath);
+    // -----------------------------
+    // 5. OUTPUT PATH
+    // -----------------------------
+    const out = outPath
+        ? path_1.default.resolve(outPath)
+        : path_1.default.join(process.cwd(), "build/app.apk");
+    // -----------------------------
+    // 6. ANDROID ROOT
+    // -----------------------------
+    const androidRoot = path_1.default.resolve(process.cwd(), "android-template");
+    return {
+        manifest,
+        dist: path_1.default.resolve(web),
+        out,
+        androidRoot,
+        mode,
+    };
+}