ota-manager 1.0.7 → 1.0.14

package/README.md

@@ -17,7 +17,7 @@ Modern mobile hybrid apps (built with Astro, Vite, or Capacitor) require a robus
 *   🔄 **Flexible CLI Shorthands**: Supports both `npx ota-manager` and `npx ota-updates`. Features lightning-fast shorthands like `npx ota-manager -d training` and `-d live`.
 *   🔀 **Multi-Provider & Multi-Channel Routing**: Built-in support for GitHub and GitLab strategies. Configure independent target repositories and branches for `training` vs `live` environments.
 *   🛡️ **Size Guardian Protocol**: Pre-flight audit of your `dist/` directory and generated ZIP archive to prevent Zip Bombs (>50MB threshold protection).
-*   💥 **Tsar Bomba Path Cleanse (`flatten-dist.cjs`)**: Post-build normalization of absolute asset paths (`/assets/`) to relative paths (`./assets/`) to guarantee flawless Capacitor WebView navigation.
+*   ⚙️ **Absolute Path Normalization (`flatten-dist.cjs`)**: Post-build normalization of absolute asset paths (`/assets/`) to relative paths (`./assets/`) to guarantee flawless Capacitor WebView navigation.
 *   🙈 **API Route Protection**: Automatically isolates and hides `/src/pages/api` during static export/build to prevent build failures, then restores them seamlessly.
 *   🔐 **Security Auditor (`ota-security.js`)**: Automated inspection of Personal Access Tokens (PAT) to prevent token leaks or overly broad repository access.
 *   📡 **E2E Connection Simulation**: Built-in `test` command to simulate push and read capabilities against your Git provider before executing actual deployments.
@@ -124,7 +124,7 @@ PUBLIC_OTA_UPDATE_URL=https://raw.githubusercontent.com/your-org/your-ota-repo/m
 └─────────────────────────────┬────────────────────────────┘
                               ▼
 ┌──────────────────────────────────────────────────────────┐
-│ 3. Build & Tsar Bomba Cleanse: Normalizes /assets/ paths │
+│ 3. Build & Path Normalization: Normalizes /assets/ paths │
 └─────────────────────────────┬────────────────────────────┘
                               ▼
 ┌──────────────────────────────────────────────────────────┐

package/lib/flatten-dist.cjs

@@ -2,9 +2,12 @@ const fs = require('fs');
 const path = require('path');
 
 /**
- * SAPU JAGAT 4.0 (TSAR BOMBA): 
+ * ABSOLUTE PATH NORMALIZATION UTILITY: 
  * Menghancurkan SEMUA variasi "/assets/" dan ".//assets/" di seluruh file
  * tanpa peduli ada tanda kutip atau tidak.
+ 
+   Catatan: Mengubah jalur absolut menjadi relatif agar aplikasi Capacitor
+   dapat merender aset dengan benar di WebView lokal.
  */
 function fixPathsInFile(filePath) {
     let content = fs.readFileSync(filePath, 'utf8');
@@ -32,7 +35,7 @@ function fixPathsInFile(filePath) {
     
     if (content !== fixedContent) {
         fs.writeFileSync(filePath, fixedContent);
-        console.log(`   💣 TSAR BOMBA FIX in: ${path.basename(filePath)}`);
+        console.log(`   ⚙️ PATH NORMALIZATION in: ${path.basename(filePath)}`);
     }
 }
 
@@ -70,7 +73,7 @@ function flatten(dir, rootDir = dir) {
 
 const distPath = path.join(process.cwd(), 'dist');
 if (fs.existsSync(distPath)) {
-    console.log('🚀 SAPU JAGAT 4.0: Launching Tsar Bomba Path Cleanse...');
+    console.log('🚀 PATH NORMALIZATION: Running absolute path normalization...');
     flatten(distPath);
     console.log('✅ ALL PATHS ARE NOW 100% PURE RELATIVE!');
 } else {

package/lib/ota-build.cjs

@@ -1,280 +1,508 @@
-const { execSync } from 'child_process';
-const fs = require('fs');
-const path = require('path');
-const https = require('https');
-
-const rootDir = process.cwd();
-const envPath = path.join(rootDir, '.env');
-if (fs.existsSync(envPath)) {
-    const envContent = fs.readFileSync(envPath, 'utf8');
-    envContent.split('\n').forEach(line => {
-        const match = line.match(/^\s*([\w.-]+)\s*=\s*(.*)?\s*$/);
-        if (match) {
-            const key = match[1];
-            let value = match[2] || '';
-            if (value.length > 0 && value.startsWith('"') && value.endsWith('"')) value = value.slice(1, -1);
-            if (value.length > 0 && value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
-            process.env[key] = value.trim();
-        }
-    });
-}
-
-const argTarget = process.argv[2]; // 'ios' or 'android'
-const GITHUB_TOKEN = process.env.GITHUB_DEV_PAT;
-const REPO = "firstryan-sbr/180spm"; 
-const WORKFLOW_ID = "ios-build.yml";
-
-async function run() {
-    if (!argTarget) {
-        console.log('\n❌ Error: Please specify target (ios or android)');
-        console.log('💡 Usage: npx ota-updates build ios\n');
-        process.exit(1);
-    }
-
-    syncBranding();
-
-    if (argTarget === 'ios') {
-        await buildIos();
-    } else if (argTarget === 'android') {
-        await buildAndroid();
-    } else {
-        console.log(`❌ Error: Unknown target '${argTarget}'`);
-        process.exit(1);
-    }
-}
-
-async function buildIos() {
-    if (!GITHUB_TOKEN) {
-        console.log('❌ Error: GITHUB_DEV_PAT missing in .env');
-        process.exit(1);
-    }
-
-    console.log('\n🍏 --- STARTING INTELLIGENT iOS BUILD ---');
-    
-    const branch = execSync('git branch --show-current').toString().trim();
-    console.log(`🌿 Branch: ${branch}`);
-
-    console.log('🔍 Checking for active builds on GitHub...');
-    const activeRuns = await githubApi(`/repos/${REPO}/actions/runs?status=in_progress&branch=${branch}&workflow=${WORKFLOW_ID}`);
-    const queuedRuns = await githubApi(`/repos/${REPO}/actions/runs?status=queued&branch=${branch}&workflow=${WORKFLOW_ID}`);
-    
-    let runId = null;
-    if ((activeRuns.workflow_runs && activeRuns.workflow_runs.length > 0) || (queuedRuns.workflow_runs && queuedRuns.workflow_runs.length > 0)) {
-        const existing = (activeRuns.workflow_runs && activeRuns.workflow_runs[0]) || (queuedRuns.workflow_runs && queuedRuns.workflow_runs[0]);
-        runId = existing.id;
-        console.log(`⚠️  Build already in progress (ID: ${runId}). Joining existing instance...`);
-    } else {
-        console.log('📦 Checking for changes to push...');
-        try {
-            execSync('git add .', { stdio: 'ignore' });
-            const status = execSync('git status --porcelain').toString();
-            if (status) {
-                console.log('📤 Pushing changes to GitHub...');
-                execSync('git commit -m "chore: automated build sync"', { stdio: 'ignore' });
-                execSync('git push origin development', { stdio: 'ignore' });
-                console.log('✅ Changes pushed! Triggering new build...');
-                await sleep(2000);
-            } else {
-                console.log('✅ No local changes. Checking if we need to trigger manually...');
-            }
-        } catch (e) {
-            console.log('⚠️ Git push skipped (maybe no changes).');
-        }
-
-        console.log('🚀 Triggering GitHub Action...');
-        try {
-            await githubApi(`/repos/${REPO}/actions/workflows/${WORKFLOW_ID}/dispatches`, 'POST', {
-                ref: branch
-            });
-            console.log('✅ Trigger Success! Waiting for run to start...');
-        } catch (e) {
-            console.error('❌ Failed to trigger build:', e.message);
-            process.exit(1);
-        }
-    }
-
-    let attempts = 0;
-    while (!runId && attempts < 10) {
-        await sleep(3000);
-        const runs = await githubApi(`/repos/${REPO}/actions/runs?branch=${branch}&per_page=5`);
-        if (runs.workflow_runs && runs.workflow_runs.length > 0) {
-            const latest = runs.workflow_runs[0];
-            if (latest.status !== 'completed') {
-                runId = latest.id;
-                console.log(`🆔 Run ID: ${runId}`);
-            }
-        }
-        attempts++;
-    }
-
-    if (!runId) {
-        console.log('❌ Could not find the started run. Please check GitHub Actions web UI.');
-        process.exit(1);
-    }
-
-    console.log('⏳ Monitoring Progress (This may take 5-10 minutes)...');
-    let status = 'queued';
-    let startTime = Date.now();
-    
-    while (status !== 'completed') {
-        await sleep(5000);
-        const runData = await githubApi(`/repos/${REPO}/actions/runs/${runId}`);
-        status = runData.status;
-        const conclusion = runData.conclusion;
-        const elapsed = Math.floor((Date.now() - startTime) / 1000);
-        
-        process.stdout.write(`\r🔄 Status: [${status.toUpperCase()}] | Time: ${elapsed}s ... `);
-
-        if (status === 'completed') {
-            console.log('\n');
-            if (conclusion === 'success') {
-                console.log('✨ iOS BUILD SUCCESS!');
-                await downloadArtifact(runId);
-            } else {
-                console.log(`❌ iOS BUILD FAILED (Conclusion: ${conclusion})`);
-                console.log(`🔗 Log: https://github.com/${REPO}/actions/runs/${runId}`);
-                process.exit(1);
-            }
-        }
-    }
-}
-
-async function downloadArtifact(runId) {
-    console.log('📥 Finding artifact to download...');
-    const artifactsData = await githubApi(`/repos/${REPO}/actions/runs/${runId}/artifacts`);
-    
-    if (!artifactsData.artifacts || artifactsData.artifacts.length === 0) {
-        console.log('❌ No artifacts found for this run.');
-        return;
-    }
-
-    const artifact = artifactsData.artifacts[0];
-    const targetDir = path.join(rootDir, 'ios', 'release');
-    if (!fs.existsSync(targetDir)) fs.mkdirSync(targetDir, { recursive: true });
-    
-    const targetFile = path.join(targetDir, 'ios-build.zip');
-    
-    console.log(`📥 Downloading ${artifact.name} to ${targetFile}...`);
-    
-    try {
-        execSync(`curl.exe -L -H "Authorization: token ${GITHUB_TOKEN}" -o "${targetFile}" "${artifact.archive_download_url}"`, { stdio: 'inherit' });
-        console.log('\n✅ Download Complete!');
-        console.log(`📦 Path: ${targetFile}`);
-        console.log('💡 Unzip and use Sideloadly to install on iPhone.\n');
-    } catch (e) {
-        console.error('❌ Download failed:', e.message);
-    }
-}
-
-async function buildAndroid() {
-    console.log('\n🤖 --- STARTING LOCAL ANDROID BUILD ---');
-    console.log('⚠️  Note: This requires Java JDK and Android Studio/SDK installed.');
-    
-    try {
-        console.log('🏗️ Building Astro & Syncing Capacitor...');
-        
-        const apiDir = path.join(rootDir, 'src', 'pages', 'api');
-        const apiBackupDir = path.join(rootDir, 'src', '_api-backup');
-        let apiHidden = false;
-
-        if (fs.existsSync(apiDir)) {
-            console.log('🙈 Hiding API routes to allow static build...');
-            if (fs.existsSync(apiBackupDir)) fs.rmSync(apiBackupDir, { recursive: true, force: true });
-            fs.renameSync(apiDir, apiBackupDir);
-            apiHidden = true;
-        }
-
-        try {
-            execSync('npm run build', { stdio: 'inherit', cwd: rootDir, env: process.env });
-        } finally {
-            if (apiHidden && fs.existsSync(apiBackupDir)) {
-                console.log('🐵 Restoring API routes...');
-                fs.renameSync(apiBackupDir, apiDir);
-            }
-        }
-
-        execSync('npx cap sync android', { stdio: 'inherit', cwd: rootDir, env: process.env });
-
-        console.log('☕ Running Gradle Build (AssembleDebug)...');
-        const gradleCmd = process.platform === 'win32' ? '.\\gradlew.bat' : './gradlew';
-        const androidDir = path.join(rootDir, 'android');
-        
-        execSync(`${gradleCmd} assembleDebug`, { stdio: 'inherit', cwd: androidDir });
-
-        const apkPath = path.join(androidDir, 'app', 'build', 'outputs', 'apk', 'debug', 'app-debug.apk');
-        const targetDir = path.join(rootDir, 'android', 'release');
-        if (!fs.existsSync(targetDir)) fs.mkdirSync(targetDir, { recursive: true });
-        
-        const finalApk = path.join(targetDir, `180spm-v${process.env.PUBLIC_APP_VERSION || 'debug'}.apk`);
-        fs.copyFileSync(apkPath, finalApk);
-
-        console.log('\n✅ ANDROID BUILD SUCCESS!');
-        console.log(`📦 Path: ${finalApk}\n`);
-    } catch (e) {
-        console.error('\n❌ Android Build Failed:', e.message);
-        process.exit(1);
-    }
-}
-
-function githubApi(endpoint, method = 'GET', data = null) {
-    return new Promise((resolve, reject) => {
-        const options = {
-            hostname: 'api.github.com',
-            path: endpoint,
-            method: method,
-            headers: {
-                'Authorization': `token ${GITHUB_TOKEN}`,
-                'User-Agent': 'OTA-Manager-CLI',
-                'Accept': 'application/vnd.github.v3+json',
-                'Content-Type': 'application/json'
-            }
-        };
-
-        const req = https.request(options, (res) => {
-            let body = '';
-            res.on('data', (chunk) => body += chunk);
-            res.on('end', () => {
-                if (res.statusCode >= 400) {
-                    return reject(new Error(`GitHub API Error: ${res.statusCode} - ${body}`));
-                }
-                try {
-                    resolve(body ? JSON.parse(body) : {});
-                } catch (e) {
-                    resolve({});
-                }
-            });
-        });
-
-        req.on('error', (e) => reject(e));
-        if (data) req.write(JSON.stringify(data));
-        req.end();
-    });
-}
-
-function syncBranding() {
-    const appName = process.env.PUBLIC_APP_NAME || '180spm';
-    console.log(`✨ Syncing Branding: [${appName}]`);
-
-    try {
-        const androidStringsPath = path.join(rootDir, 'android', 'app', 'src', 'main', 'res', 'values', 'strings.xml');
-        if (fs.existsSync(androidStringsPath)) {
-            let content = fs.readFileSync(androidStringsPath, 'utf8');
-            content = content.replace(/<string name="app_name">.*?<\/string>/, `<string name="app_name">${appName}<\/string>`);
-            fs.writeFileSync(androidStringsPath, content);
-        }
-
-        const iosPlistPath = path.join(rootDir, 'ios', 'App', 'App', 'Info.plist');
-        if (fs.existsSync(iosPlistPath)) {
-            let content = fs.readFileSync(iosPlistPath, 'utf8');
-            content = content.replace(/<key>CFBundleDisplayName<\/key>\s*<string>.*?<\/string>/, `<key>CFBundleDisplayName<\/key>\n\t<string>${appName}<\/string>`);
-            fs.writeFileSync(iosPlistPath, content);
-        }
-        console.log('✅ Branding synchronized across platforms.');
-    } catch (e) {
-        console.error('⚠️ Warning: Failed to sync branding:', e.message);
-    }
-}
-
-function sleep(ms) { return new Promise(resolve => setTimeout(resolve, ms)); }
-
-run();
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const readline = require('readline');
+const crypto = require('crypto');
+
+function confirm(message) {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        rl.question(`\n⚠️  ${message} [y/N]: `, (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase() === 'y');
+        });
+    });
+}
+
+function getDirHash(dirPath) {
+    if (!fs.existsSync(dirPath)) return '';
+    const hash = crypto.createHash('sha256');
+    const files = fs.readdirSync(dirPath, { recursive: true });
+    files.sort().forEach(file => {
+        const fullPath = path.join(dirPath, file);
+        const stats = fs.statSync(fullPath);
+        if (stats.isFile()) {
+            hash.update(file);
+            hash.update(fs.readFileSync(fullPath));
+        }
+    });
+    return hash.digest('hex');
+}
+
+const rootDir = process.cwd();
+const envPath = path.join(rootDir, '.env');
+if (fs.existsSync(envPath)) {
+    const envContent = fs.readFileSync(envPath, 'utf8');
+    envContent.split('\n').forEach(line => {
+        const match = line.match(/^\s*([\w.-]+)\s*=\s*(.*)?\s*$/);
+        if (match) {
+            const key = match[1];
+            let value = match[2] || '';
+            if (value.length > 0 && value.startsWith('"') && value.endsWith('"')) value = value.slice(1, -1);
+            if (value.length > 0 && value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+            process.env[key] = value.trim();
+        }
+    });
+}
+
+const rawArgs = process.argv.slice(2).map(a => a.toLowerCase());
+const hasNv = rawArgs.includes('-nv') || rawArgs.includes('--nv') || rawArgs.includes('--no-version') || rawArgs.includes('nover') || rawArgs.includes('no-ver') || rawArgs.includes('-no') || rawArgs.includes('--no') || rawArgs.includes('no') || rawArgs.includes('-norev') || rawArgs.includes('--norev') || rawArgs.includes('norev');
+
+const cleanArgs = rawArgs.filter(a => !a.startsWith('-') && a !== 'nover' && a !== 'no-ver' && a !== 'no' && a !== 'norev');
+const rawTarget = cleanArgs[0] || '';
+const rawType = cleanArgs[1] || '';
+
+let argTarget = rawTarget;
+let buildType = rawType;
+if (rawTarget === 'apk' || rawTarget === 'aab' || rawTarget === 'bundle') {
+    argTarget = 'android';
+    if (rawTarget === 'aab' || rawTarget === 'bundle') buildType = 'bundle';
+}
+if (rawTarget === 'ipa') argTarget = 'ios';
+const GITHUB_TOKEN = process.env.GITHUB_DEV_PAT;
+const REPO = "firstryan-sbr/180spm"; 
+const WORKFLOW_ID = "ios-build.yml";
+
+async function run() {
+    if (!argTarget) {
+        console.log('\n❌ Error: Please specify target (ios or android)');
+        console.log('💡 Usage: npx ota-manager build ios\n');
+        process.exit(1);
+    }
+
+    syncBranding();
+
+    const otaConfigPath = path.join(rootDir, 'ota-config.json');
+    let strategy = 'github';
+    let repoUrl = '';
+    if (fs.existsSync(otaConfigPath)) {
+        const otaConfig = JSON.parse(fs.readFileSync(otaConfigPath, 'utf8'));
+        strategy = otaConfig.strategy || 'github';
+        repoUrl = otaConfig[strategy]?.repo || '';
+    }
+
+    const otaReleasesDir = path.join(rootDir, 'ota-releases');
+    if (repoUrl) {
+        console.log(`📂 Preparing remote OTA repository to synchronize version & hash...`);
+        const pat = process.env.GITHUB_DEV_PAT || process.env.GITLAB_DEV_PAT || '';
+        const cloneRepo = repoUrl.endsWith('.git') ? repoUrl : repoUrl + '.git';
+        const authRepo = cloneRepo.replace('https://', `https://${pat}@`);
+        if (fs.existsSync(otaReleasesDir)) fs.rmSync(otaReleasesDir, { recursive: true, force: true });
+        try {
+            execSync(`git clone --depth 1 ${authRepo} "${otaReleasesDir}"`, { stdio: 'ignore' });
+        } catch (e) {
+            console.log('⚠️ Could not clone remote repo, falling back to existing manifest if available.');
+        }
+    }
+
+    const manifestPath = path.join(otaReleasesDir, 'manifest.json');
+    let previousVersion = process.env.PUBLIC_APP_VERSION_ANDROID || '0.1.9.0';
+    let previousHash = null;
+    if (fs.existsSync(manifestPath)) {
+        const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+        previousVersion = manifest.version || manifest.live?.version || previousVersion;
+        previousHash = manifest.hash || manifest.live?.hash || null;
+    }
+
+    console.log('🏗️ Building project for Smart Diff Check...');
+    const apiDir = path.join(rootDir, 'src', 'pages', 'api');
+    const apiBackupDir = path.join(rootDir, 'src', '_api-backup');
+    let apiHidden = false;
+    if (fs.existsSync(apiDir)) {
+        console.log('🙈 Hiding API routes (Using Robust Move)...');
+        if (fs.existsSync(apiBackupDir)) fs.rmSync(apiBackupDir, { recursive: true, force: true });
+        if (process.platform === 'win32') {
+            try { execSync(`robocopy "${apiDir}" "${apiBackupDir}" /E /MOVE /NFL /NDL /NJH /NJS`, { stdio: 'ignore' }); } catch (e) { if (fs.existsSync(apiDir)) throw e; }
+        } else {
+            fs.renameSync(apiDir, apiBackupDir);
+        }
+        apiHidden = true;
+    }
+    try {
+        execSync('npm run build', { stdio: 'inherit', cwd: rootDir, env: process.env });
+    } finally {
+        if (apiHidden && fs.existsSync(apiBackupDir)) {
+            console.log('🐵 Restoring API routes...');
+            if (process.platform === 'win32') {
+                try { execSync(`robocopy "${apiBackupDir}" "${apiDir}" /E /MOVE /NFL /NDL /NJH /NJS`, { stdio: 'ignore' }); } catch (e) { if (fs.existsSync(apiBackupDir)) throw e; }
+            } else {
+                fs.renameSync(apiBackupDir, apiDir);
+            }
+        }
+    }
+
+    console.log('🧠 Calculating SHA-256 Hash of dist/ artifacts...');
+    const distDir = path.join(rootDir, 'dist');
+    const currentBuildHash = getDirHash(distDir);
+    console.log(`🔑 Current Build Hash : ${currentBuildHash.substring(0, 16)}...`);
+    if (previousHash) console.log(`🔒 Previous Release Hash: ${previousHash.substring(0, 16)}...`);
+
+    let activeVersion = previousVersion;
+    let isChanged = (!previousHash || previousHash !== currentBuildHash);
+
+    if (hasNv) {
+        activeVersion = process.env.PUBLIC_APP_VERSION || process.env.PUBLIC_APP_VERSION_ANDROID || previousVersion;
+        console.log(`\n🛡️ [FLAG -nv DETECTED] Mempertahankan versi lokal saat ini: ${activeVersion} (No version increment)`);
+    } else if (!isChanged) {
+        console.log(`\nℹ️ [SMART DIFF CHECKER] No code changes detected in build artifacts.`);
+        console.log(`📄 Version maintained at: ${previousVersion} (No version increment)`);
+        
+        const ext = (buildType === 'bundle' || buildType === 'aab') ? 'aab' : 'apk';
+        const existingPath = argTarget === 'android' 
+            ? path.join(rootDir, 'android', 'release', `180spm-${previousVersion}.${ext}`)
+            : path.join(rootDir, 'ios', 'release', 'ios-build.zip');
+            
+        console.log(`📦 ${argTarget.toUpperCase()} file for this version is already available at:\n   👉 ${existingPath}`);
+        
+        const proceed = await confirm(`Do you want to force rebuild ${argTarget.toUpperCase()} anyway?`);
+        if (!proceed) {
+            console.log('\n❌ Build cancelled. Please use the existing file at the specified path.\n');
+            process.exit(0);
+        }
+    } else {
+        const parts = previousVersion.split('.');
+        const lastIdx = parts.length - 1;
+        const oldPart = parts[lastIdx];
+        const oldLen = oldPart.length;
+        parts[lastIdx] = (parseInt(oldPart) + 1).toString().padStart(oldLen, '0');
+        const nextVersion = parts.join('.');
+        
+        console.log(`\n🔍 Code changes detected!`);
+        console.log(`📈 Version will increment: ${previousVersion} -> ${nextVersion}`);
+        
+        const proceed = await confirm(`Do you want to proceed building ${argTarget.toUpperCase()} with the new version (${nextVersion})?`);
+        if (!proceed) {
+            console.log('\n❌ Build cancelled.\n');
+            process.exit(0);
+        }
+        
+        activeVersion = nextVersion;
+        console.log(`📝 Updating .env & manifest to version ${activeVersion}...`);
+        const envPath = path.join(rootDir, '.env');
+        if (fs.existsSync(envPath)) {
+            let envContent = fs.readFileSync(envPath, 'utf8');
+            envContent = envContent.replace(/PUBLIC_APP_VERSION_ANDROID=.*/, `PUBLIC_APP_VERSION_ANDROID=${activeVersion}`);
+            envContent = envContent.replace(/PUBLIC_APP_VERSION_IOS=.*/, `PUBLIC_APP_VERSION_IOS=${activeVersion}`);
+            if (envContent.includes('PUBLIC_APP_VERSION=')) {
+                envContent = envContent.replace(/PUBLIC_APP_VERSION=.*/, `PUBLIC_APP_VERSION=${activeVersion}`);
+            }
+            fs.writeFileSync(envPath, envContent);
+            process.env.PUBLIC_APP_VERSION = activeVersion;
+        }
+        const mainManifestPath = path.join(rootDir, 'src', 'data', 'update-data.json');
+        if (fs.existsSync(mainManifestPath)) {
+            const manifest = JSON.parse(fs.readFileSync(mainManifestPath, 'utf8'));
+            manifest.version = activeVersion;
+            fs.writeFileSync(mainManifestPath, JSON.stringify(manifest, null, 2));
+        }
+        const pkgJsonPath = path.join(rootDir, 'package.json');
+        if (fs.existsSync(pkgJsonPath)) {
+            const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));
+            pkgJson.version = activeVersion;
+            fs.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
+        }
+    }
+
+    if (argTarget === 'ios') {
+        await buildIos();
+    } else if (argTarget === 'android') {
+        await buildAndroid(activeVersion, buildType);
+    } else {
+        console.log(`❌ Error: Unknown target '${argTarget}'`);
+        process.exit(1);
+    }
+}
+
+async function buildIos() {
+    if (!GITHUB_TOKEN) {
+        console.log('❌ Error: GITHUB_DEV_PAT missing in .env');
+        process.exit(1);
+    }
+
+    const activeWorkflowId = buildType === 'release' ? 'ios-release.yml' : 'ios-build.yml';
+    const buildModeName = buildType === 'release' ? 'App Store Release' : 'Free Sideloading';
+    console.log(`\n🍏 --- STARTING INTELLIGENT iOS BUILD [${buildModeName.toUpperCase()}] ---`);
+    
+    const branch = execSync('git branch --show-current').toString().trim();
+    console.log(`🌿 Branch: ${branch}`);
+
+    console.log('🔍 Checking for active builds on GitHub...');
+    const activeRuns = await githubApi(`/repos/${REPO}/actions/runs?status=in_progress&branch=${branch}&workflow=${activeWorkflowId}`);
+    const queuedRuns = await githubApi(`/repos/${REPO}/actions/runs?status=queued&branch=${branch}&workflow=${activeWorkflowId}`);
+    
+    let runId = null;
+    if ((activeRuns.workflow_runs && activeRuns.workflow_runs.length > 0) || (queuedRuns.workflow_runs && queuedRuns.workflow_runs.length > 0)) {
+        const existing = (activeRuns.workflow_runs && activeRuns.workflow_runs[0]) || (queuedRuns.workflow_runs && queuedRuns.workflow_runs[0]);
+        runId = existing.id;
+        console.log(`⚠️  Build already in progress (ID: ${runId}). Joining existing instance...`);
+    } else {
+        console.log('📦 Checking for changes to push...');
+        try {
+            execSync('git add .', { stdio: 'ignore' });
+            const status = execSync('git status --porcelain').toString();
+            if (status) {
+                console.log('📤 Pushing changes to GitHub...');
+                execSync('git commit -m "chore: automated build sync"', { stdio: 'ignore' });
+                execSync(`git push origin ${branch}`, { stdio: 'ignore' });
+                console.log('✅ Changes pushed!');
+                await sleep(2000);
+            } else {
+                console.log('✅ No local file changes. Ensuring active branch ref is pushed to remote...');
+                execSync(`git push origin ${branch}`, { stdio: 'ignore' });
+            }
+        } catch (e) {
+            console.log('⚠️ Git push skipped or branch already up to date on remote.');
+        }
+
+        console.log('🚀 Triggering GitHub Action...');
+        try {
+            const payload = { ref: branch };
+            if (activeWorkflowId === 'ios-build.yml') {
+                payload.inputs = {
+                    channel: process.env.PUBLIC_APP_CHANNEL || 'training',
+                    api_url: process.env.PUBLIC_API_URL || '',
+                    github_ota_pat: process.env.PUBLIC_GITHUB_OTA_PAT || '',
+                    ota_update_url: process.env.PUBLIC_OTA_UPDATE_URL || ''
+                };
+            }
+            await githubApi(`/repos/${REPO}/actions/workflows/${activeWorkflowId}/dispatches`, 'POST', payload);
+            console.log('✅ Trigger Success! Waiting for run to start...');
+        } catch (e) {
+            console.error('❌ Failed to trigger build:', e.message);
+            process.exit(1);
+        }
+    }
+
+    let attempts = 0;
+    while (!runId && attempts < 10) {
+        await sleep(3000);
+        const runs = await githubApi(`/repos/${REPO}/actions/runs?branch=${branch}&per_page=5`);
+        if (runs.workflow_runs && runs.workflow_runs.length > 0) {
+            const latest = runs.workflow_runs[0];
+            if (latest.status !== 'completed') {
+                runId = latest.id;
+                console.log(`🆔 Run ID: ${runId}`);
+            }
+        }
+        attempts++;
+    }
+
+    if (!runId) {
+        console.log('❌ Could not find the started run. Please check GitHub Actions web UI.');
+        process.exit(1);
+    }
+
+    console.log('⏳ Monitoring Progress (This may take 5-10 minutes)...');
+    let status = 'queued';
+    let startTime = Date.now();
+    
+    while (status !== 'completed') {
+        await sleep(5000);
+        const runData = await githubApi(`/repos/${REPO}/actions/runs/${runId}`);
+        status = runData.status;
+        const conclusion = runData.conclusion;
+        const elapsed = Math.floor((Date.now() - startTime) / 1000);
+        
+        process.stdout.write(`\r🔄 Status: [${status.toUpperCase()}] | Time: ${elapsed}s ... `);
+
+        if (status === 'completed') {
+            console.log('\n');
+            if (conclusion === 'success') {
+                console.log(`✨ iOS BUILD SUCCESS [${buildModeName.toUpperCase()}]!`);
+                await downloadArtifact(runId);
+            } else {
+                console.log(`❌ iOS BUILD FAILED (Conclusion: ${conclusion})`);
+                console.log(`🔗 Log: https://github.com/${REPO}/actions/runs/${runId}`);
+                process.exit(1);
+            }
+        }
+    }
+}
+
+async function downloadArtifact(runId) {
+    console.log('📥 Finding artifact to download...');
+    const artifactsData = await githubApi(`/repos/${REPO}/actions/runs/${runId}/artifacts`);
+    
+    if (!artifactsData.artifacts || artifactsData.artifacts.length === 0) {
+        console.log('❌ No artifacts found for this run.');
+        return;
+    }
+
+    const artifact = artifactsData.artifacts[0];
+    const targetDir = path.join(rootDir, 'ios', 'release');
+    if (!fs.existsSync(targetDir)) fs.mkdirSync(targetDir, { recursive: true });
+    
+    const zipName = buildType === 'release' ? 'ios-release.zip' : 'ios-build.zip';
+    const targetFile = path.join(targetDir, zipName);
+    
+    console.log(`📥 Downloading ${artifact.name} to ${targetFile}...`);
+    
+    try {
+        execSync(`curl.exe -L -H "Authorization: token ${GITHUB_TOKEN}" -o "${targetFile}" "${artifact.archive_download_url}"`, { stdio: 'inherit' });
+        console.log('\n✅ Download Complete!');
+        console.log(`📦 Path: ${targetFile}`);
+        if (buildType === 'release') {
+            console.log('💡 Unzip the package to retrieve the signed "180spm-release.ipa".');
+            console.log('💡 You can now upload this .ipa file directly to Apple TestFlight or App Store Connect.\n');
+        } else {
+            console.log('💡 Unzip and use Sideloadly to install on iPhone.\n');
+        }
+    } catch (e) {
+        console.error('❌ Download failed:', e.message);
+    }
+}
+
+async function buildAndroid(activeVersion, buildType) {
+    console.log('\n🤖 --- STARTING LOCAL ANDROID BUILD ---');
+    console.log('⚠️  Note: This requires Java JDK and Android Studio/SDK installed.');
+    
+    try {
+        console.log('🔄 Syncing Capacitor Android...');
+        execSync('npx cap sync android', { stdio: 'inherit', cwd: rootDir, env: process.env });
+
+        const isBundle = buildType === 'bundle' || buildType === 'aab';
+        const isRelease = isBundle || buildType === 'release';
+        const task = isBundle ? 'bundleRelease' : (isRelease ? 'assembleRelease' : 'assembleDebug');
+        const modeName = isBundle ? 'App Bundle (Release)' : (isRelease ? 'APK (Release)' : 'APK (Debug)');
+
+        console.log(`☕ Running Gradle Build (${task})...`);
+        const gradleCmd = process.platform === 'win32' ? '.\\gradlew.bat' : './gradlew';
+        const androidDir = path.join(rootDir, 'android');
+        
+        execSync(`${gradleCmd} ${task}`, { stdio: 'inherit', cwd: androidDir });
+
+        const targetDir = path.join(rootDir, 'android', 'release');
+        if (!fs.existsSync(targetDir)) fs.mkdirSync(targetDir, { recursive: true });
+        
+        let sourcePath = '';
+        const ext = isBundle ? 'aab' : 'apk';
+        
+        if (isBundle) {
+            sourcePath = path.join(androidDir, 'app', 'build', 'outputs', 'bundle', 'release', 'app-release.aab');
+        } else if (isRelease) {
+            sourcePath = path.join(androidDir, 'app', 'build', 'outputs', 'apk', 'release', 'app-release.apk');
+        } else {
+            sourcePath = path.join(androidDir, 'app', 'build', 'outputs', 'apk', 'debug', 'app-debug.apk');
+        }
+        
+        const finalFile = path.join(targetDir, `180spm-${activeVersion || 'debug'}.${ext}`);
+        fs.copyFileSync(sourcePath, finalFile);
+
+        console.log(`\n✅ ANDROID BUILD SUCCESS (${modeName})!`);
+        console.log(`📦 Path: ${finalFile}\n`);
+    } catch (e) {
+        console.error('\n❌ Android Build Failed:', e.message);
+        process.exit(1);
+    }
+}
+
+function githubApi(endpoint, method = 'GET', data = null) {
+    return new Promise((resolve, reject) => {
+        const options = {
+            hostname: 'api.github.com',
+            path: endpoint,
+            method: method,
+            headers: {
+                'Authorization': `token ${GITHUB_TOKEN}`,
+                'User-Agent': 'OTA-Manager-CLI',
+                'Accept': 'application/vnd.github.v3+json',
+                'Content-Type': 'application/json'
+            }
+        };
+
+        const req = https.request(options, (res) => {
+            let body = '';
+            res.on('data', (chunk) => body += chunk);
+            res.on('end', () => {
+                if (res.statusCode >= 400) {
+                    return reject(new Error(`GitHub API Error: ${res.statusCode} - ${body}`));
+                }
+                try {
+                    resolve(body ? JSON.parse(body) : {});
+                } catch (e) {
+                    resolve({});
+                }
+            });
+        });
+
+        req.on('error', (e) => reject(e));
+        if (data) req.write(JSON.stringify(data));
+        req.end();
+    });
+}
+
+function syncBranding() {
+    const appName = process.env.PUBLIC_APP_NAME || '180spm';
+    const appId = process.env.PUBLIC_APP_ID || 'com.cyclopedia.one_eighty_run';
+    const appVer = process.env.PUBLIC_APP_VERSION || process.env.PUBLIC_APP_VERSION_ANDROID || '2.0.00';
+    console.log(`✨ Syncing Branding & Version: [${appName} (${appId}) - ${appVer}]`);
+
+    try {
+        const androidStringsPath = path.join(rootDir, 'android', 'app', 'src', 'main', 'res', 'values', 'strings.xml');
+        if (fs.existsSync(androidStringsPath)) {
+            let content = fs.readFileSync(androidStringsPath, 'utf8');
+            content = content.replace(/<string name="app_name">.*?<\/string>/, `<string name="app_name">${appName}<\/string>`);
+            fs.writeFileSync(androidStringsPath, content);
+        }
+
+        const partsStr = appVer.split('.');
+        let majorStr = partsStr[0] || '0';
+        let minorStr = partsStr[1] || '0';
+        let patchStr = partsStr[2] || '00';
+        if (patchStr.length === 1) patchStr = '0' + patchStr;
+        const versionCodeNum = parseInt(`${majorStr}${minorStr}${patchStr}`, 10) || 1;
+
+        const buildGradlePath = path.join(rootDir, 'android', 'app', 'build.gradle');
+        if (fs.existsSync(buildGradlePath)) {
+            let bgContent = fs.readFileSync(buildGradlePath, 'utf8');
+            bgContent = bgContent.replace(/applicationId\s+".*?"/, `applicationId "${appId}"`);
+            bgContent = bgContent.replace(/versionCode\s+\d+/, `versionCode ${versionCodeNum}`);
+            bgContent = bgContent.replace(/versionName\s+".*?"/, `versionName "${appVer}"`);
+            fs.writeFileSync(buildGradlePath, bgContent);
+        }
+
+        const iosPlistPath = path.join(rootDir, 'ios', 'App', 'App', 'Info.plist');
+        if (fs.existsSync(iosPlistPath)) {
+            let content = fs.readFileSync(iosPlistPath, 'utf8');
+            content = content.replace(/<key>CFBundleDisplayName<\/key>\s*<string>.*?<\/string>/, `<key>CFBundleDisplayName<\/key>\n\t<string>${appName}<\/string>`);
+            fs.writeFileSync(iosPlistPath, content);
+        }
+
+        const pbxprojPath = path.join(rootDir, 'ios', 'App', 'App.xcodeproj', 'project.pbxproj');
+        if (fs.existsSync(pbxprojPath)) {
+            let pbxContent = fs.readFileSync(pbxprojPath, 'utf8');
+            pbxContent = pbxContent.replace(/PRODUCT_BUNDLE_IDENTIFIER = .*?;/g, `PRODUCT_BUNDLE_IDENTIFIER = ${appId};`);
+            pbxContent = pbxContent.replace(/CURRENT_PROJECT_VERSION = \d+;/g, `CURRENT_PROJECT_VERSION = ${versionCodeNum};`);
+            pbxContent = pbxContent.replace(/MARKETING_VERSION = .*?;/g, `MARKETING_VERSION = ${appVer};`);
+            fs.writeFileSync(pbxprojPath, pbxContent);
+        }
+
+        const iosCapConfig = path.join(rootDir, 'ios', 'App', 'App', 'capacitor.config.json');
+        if (fs.existsSync(iosCapConfig)) {
+            let capContent = fs.readFileSync(iosCapConfig, 'utf8');
+            capContent = capContent.replace(/"appId":\s*".*?"/, `"appId": "${appId}"`);
+            capContent = capContent.replace(/"appName":\s*".*?"/, `"appName": "${appName}"`);
+            fs.writeFileSync(iosCapConfig, capContent);
+        }
+
+        const androidCapConfig = path.join(rootDir, 'android', 'app', 'src', 'main', 'assets', 'capacitor.config.json');
+        if (fs.existsSync(androidCapConfig)) {
+            let capContent = fs.readFileSync(androidCapConfig, 'utf8');
+            capContent = capContent.replace(/"appId":\s*".*?"/, `"appId": "${appId}"`);
+            capContent = capContent.replace(/"appName":\s*".*?"/, `"appName": "${appName}"`);
+            fs.writeFileSync(androidCapConfig, capContent);
+        }
+
+        console.log(`✅ Branding & native versions synchronized (versionCode: ${versionCodeNum}).`);
+    } catch (e) {
+        console.error('⚠️ Warning: Failed to sync branding/version:', e.message);
+    }
+}
+
+function sleep(ms) { return new Promise(resolve => setTimeout(resolve, ms)); }
+
+run();

package/lib/ota-deploy.js

@@ -160,7 +160,7 @@ async function deployOTA() {
             execSync('npm run build', { stdio: 'inherit', cwd: rootDir });
             
             if (fs.existsSync(FLATTEN_SCRIPT)) {
-                console.log('🚀 Running Tsar Bomba Path Cleanse...');
+                console.log('🚀 Running Absolute Path Normalization...');
                 execSync(`node "${FLATTEN_SCRIPT}"`, { stdio: 'inherit', cwd: rootDir });
             }
 
@@ -192,7 +192,9 @@ async function deployOTA() {
             console.log('🔍 Changes detected! Auto-incrementing from remote manifest...');
             const parts = previousVersion.split('.');
             const lastIdx = parts.length - 1;
-            parts[lastIdx] = (parseInt(parts[lastIdx]) + 1).toString();
+            const oldPart = parts[lastIdx];
+            const oldLen = oldPart.length;
+            parts[lastIdx] = (parseInt(oldPart) + 1).toString().padStart(oldLen, '0');
             nextVersion = parts.join('.');
             console.log(`📈 Auto-increment: ${previousVersion} -> ${nextVersion}`);
         }
@@ -221,12 +223,90 @@ async function deployOTA() {
         
         console.log(`📝 Updating .env to version ${nextVersion} (Android & iOS) and setting OTA target...`);
         fs.writeFileSync(ENV_PATH, updatedEnv);
+
+        const envLivePath = path.join(rootDir, '.env-live');
+        const envTrainingPath = path.join(rootDir, '.env-training');
+        if (argChannel === 'live' && fs.existsSync(envLivePath)) {
+            let liveEnv = fs.readFileSync(envLivePath, 'utf-8');
+            liveEnv = liveEnv.replace(/PUBLIC_APP_VERSION=.*/, `PUBLIC_APP_VERSION=${nextVersion}`);
+            if (liveEnv.includes('PUBLIC_OTA_UPDATE_URL=')) {
+                liveEnv = liveEnv.replace(/PUBLIC_OTA_UPDATE_URL=.*/, `PUBLIC_OTA_UPDATE_URL=${activeOtaUrl}`);
+            } else {
+                liveEnv += `\nPUBLIC_OTA_UPDATE_URL=${activeOtaUrl}`;
+            }
+            fs.writeFileSync(envLivePath, liveEnv);
+            console.log(`📝 Updated .env-live to version ${nextVersion}`);
+        }
+        if (argChannel === 'training' && fs.existsSync(envTrainingPath)) {
+            let trainingEnv = fs.readFileSync(envTrainingPath, 'utf-8');
+            trainingEnv = trainingEnv.replace(/PUBLIC_APP_VERSION=.*/, `PUBLIC_APP_VERSION=${nextVersion}`);
+            if (trainingEnv.includes('PUBLIC_OTA_UPDATE_URL=')) {
+                trainingEnv = trainingEnv.replace(/PUBLIC_OTA_UPDATE_URL=.*/, `PUBLIC_OTA_UPDATE_URL=${activeOtaUrl}`);
+            } else {
+                trainingEnv += `\nPUBLIC_OTA_UPDATE_URL=${activeOtaUrl}`;
+            }
+            fs.writeFileSync(envTrainingPath, trainingEnv);
+            console.log(`📝 Updated .env-training to version ${nextVersion}`);
+        }
         
+        // Sync Native Android & iOS Versions
+        try {
+            const partsStr = nextVersion.split('.');
+            let majorStr = partsStr[0] || '0';
+            let minorStr = partsStr[1] || '0';
+            let patchStr = partsStr[2] || '00';
+            if (patchStr.length === 1) patchStr = '0' + patchStr;
+            const versionCodeNum = parseInt(`${majorStr}${minorStr}${patchStr}`, 10) || 1;
+
+            const buildGradlePath = path.join(rootDir, 'android', 'app', 'build.gradle');
+            if (fs.existsSync(buildGradlePath)) {
+                let bgContent = fs.readFileSync(buildGradlePath, 'utf8');
+                bgContent = bgContent.replace(/versionCode\s+\d+/, `versionCode ${versionCodeNum}`);
+                bgContent = bgContent.replace(/versionName\s+".*?"/, `versionName "${nextVersion}"`);
+                fs.writeFileSync(buildGradlePath, bgContent);
+            }
+
+            const pbxprojPath = path.join(rootDir, 'ios', 'App', 'App.xcodeproj', 'project.pbxproj');
+            if (fs.existsSync(pbxprojPath)) {
+                let pbxContent = fs.readFileSync(pbxprojPath, 'utf8');
+                pbxContent = pbxContent.replace(/CURRENT_PROJECT_VERSION = \d+;/g, `CURRENT_PROJECT_VERSION = ${versionCodeNum};`);
+                pbxContent = pbxContent.replace(/MARKETING_VERSION = .*?;/g, `MARKETING_VERSION = ${nextVersion};`);
+                fs.writeFileSync(pbxprojPath, pbxContent);
+            }
+            console.log(`✅ Native Android & iOS versions synchronized (versionCode: ${versionCodeNum}).`);
+        } catch (err) {
+            console.error('⚠️ Warning: Failed to sync native versions:', err.message);
+        }
+
         if (fs.existsSync(MAIN_MANIFEST_PATH)) {
             const manifest = JSON.parse(fs.readFileSync(MAIN_MANIFEST_PATH, 'utf8'));
             manifest.version = nextVersion;
             fs.writeFileSync(MAIN_MANIFEST_PATH, JSON.stringify(manifest, null, 2));
         }
+        const pkgJsonPath = path.join(rootDir, 'package.json');
+        if (fs.existsSync(pkgJsonPath)) {
+            const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));
+            pkgJson.version = nextVersion;
+            fs.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
+        }
+
+        console.log('🏗️ Rebuilding Astro to bake new version string into JS bundle...');
+        hideApi();
+        try {
+            execSync('npm run build', { stdio: 'inherit', cwd: rootDir });
+            
+            if (fs.existsSync(FLATTEN_SCRIPT)) {
+                console.log('🚀 Running Absolute Path Normalization...');
+                execSync(`node "${FLATTEN_SCRIPT}"`, { stdio: 'inherit', cwd: rootDir });
+            }
+
+            if (fs.existsSync(VERIFY_SCRIPT)) {
+                console.log('🔍 Running Pre-Flight Verification...');
+                execSync(`node "${VERIFY_SCRIPT}"`, { stdio: 'inherit', cwd: rootDir });
+            }
+        } finally {
+            showApi();
+        }
 
         console.log('🛡️  Size Guardian: Checking dist/ folder size...');
         const distSizeBytes = getDirSize(DIST_DIR);
@@ -237,7 +317,7 @@ async function deployOTA() {
             throw new Error(`CRITICAL SIZE VIOLATION: Folder dist/ has bloated to ${distSizeMB.toFixed(2)} MB! Limit is ${MAX_OTA_SIZE_MB} MB. Packaging aborted to prevent ZIP BOMB!`);
         }
 
-        const otaName = `v${nextVersion.replace(/\./g, '_')}.zip`;
+        const otaName = `${nextVersion.replace(/\./g, '_')}.zip`;
         const otaPath = path.join(rootDir, otaName);
 
         const isWindows = process.platform === 'win32';
@@ -306,7 +386,7 @@ async function deployToRemote(otaPath, otaName, version, channel, branch, buildH
     fs.writeFileSync(flatManifestPath, JSON.stringify(manifest[channel], null, 2));
     
     execSync(`git add .`, { cwd: OTA_RELEASES_DIR });
-    execSync(`git commit -m "release: v${version} for ${channel}"`, { cwd: OTA_RELEASES_DIR });
+    execSync(`git commit -m "release: ${version} for ${channel}"`, { cwd: OTA_RELEASES_DIR });
     execSync(`git push origin ${branch}`, { cwd: OTA_RELEASES_DIR });
 
     if (fs.existsSync(otaPath)) fs.unlinkSync(otaPath);

package/lib/ota-main.js

@@ -23,6 +23,7 @@ const scripts = {
     verify: path.join(__dirname, 'verify-dist.cjs'),
     security: path.join(__dirname, 'ota-security.js'),
     build: path.join(__dirname, 'ota-build.cjs'),
+    rollback: path.join(__dirname, 'ota-rollback.js'),
 };
 
 function showHelp() {
@@ -43,9 +44,18 @@ Management Commands:
   test      : Run E2E simulation (Push & Read).
 
 Operational Commands:
-  status    : Check local vs remote version.
-  deploy training : Deploy update to TRAINING channel.
-  deploy live     : Deploy update to LIVE channel.
+  status            : Check local vs remote version.
+  deploy training   : Deploy update to TRAINING channel.
+  deploy live       : Deploy update to LIVE channel.
+  rollback <v> [ch] : Rollback / Downgrade ke versi lama (e.g., rollback 2.0.00 training).
+
+Native Build Commands:
+  build android     : Build Android APK Debug (default).
+  build android release : Build Android APK Release (assembleRelease).
+  build android bundle  : Build Android App Bundle (.aab) siap rilis Play Store.
+  build ios         : Trigger iOS GitHub Actions build & sync branding (Debug/Sideloading).
+  build ios release : Trigger iOS App Store Release signed build & sync branding.
+  * Gunakan flag 'no', 'norev', 'nover', '-no', atau '-nv' di akhir perintah untuk mencegah kenaikan versi.
 
 Active Infrastructure:
   Strategy : ${OTA_CONFIG.strategy.toUpperCase()}
@@ -125,7 +135,8 @@ async function run() {
                 break;
 
             case 'build':
-                execSync(`node "${scripts.build}" ${subArg || ''}`, { stdio: 'inherit' });
+                const allArgs = process.argv.slice(3).join(' ');
+                execSync(`node "${scripts.build}" ${allArgs}`, { stdio: 'inherit' });
                 process.exit(0);
                 break;
 
@@ -136,6 +147,22 @@ async function run() {
                 process.exit(0);
                 break;
 
+            case 'rollback':
+            case 'downgrade':
+            case 'set-version':
+                if (!subArg) {
+                    console.log('❌ Error: Mohon tentukan versi tujuan (e.g., npx ota-manager rollback 0.2.0.11 training).');
+                    process.exit(1);
+                }
+                const rbChannel = versionArg || 'training';
+                if (await confirm(`ARE YOU SURE you want to rollback ${rbChannel.toUpperCase()} to version ${subArg}?`)) {
+                    execSync(`node "${scripts.rollback}" ${subArg} ${rbChannel}`, { stdio: 'inherit' });
+                } else {
+                    console.log('❌ Rollback cancelled.');
+                }
+                process.exit(0);
+                break;
+
             case 'training':
                 execSync(`node "${scripts.version}"`, { stdio: 'inherit' });
                 execSync(`node "${scripts.verify}"`, { stdio: 'inherit' });

package/lib/ota-rollback.js

@@ -0,0 +1,130 @@
+import { execSync } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import OTA_CONFIG from './ota-config.js';
+
+const rootDir = process.cwd();
+const ENV_PATH = path.join(rootDir, '.env');
+const MAIN_MANIFEST_PATH = path.join(rootDir, 'src', 'data', 'update-data.json');
+const OTA_RELEASES_DIR = path.join(rootDir, 'ota-releases');
+
+let githubPat = '';
+let gitlabPat = '';
+if (fs.existsSync(ENV_PATH)) {
+    const envContent = fs.readFileSync(ENV_PATH, 'utf-8');
+    envContent.split('\n').forEach(line => {
+        const match = line.match(/^\s*([\w.-]+)\s*=\s*(.*)?\s*$/);
+        if (match) {
+            if (match[1] === 'GITHUB_DEV_PAT') githubPat = match[2].replace(/['"]/g, '').trim();
+            if (match[1] === 'GITLAB_DEV_PAT') gitlabPat = match[2].replace(/['"]/g, '').trim();
+        }
+    });
+}
+
+function getRawBaseUrl(repoUrl, strategy, branch = 'main') {
+    let base = repoUrl.replace(/\/$/, '');
+    if (strategy === 'github') {
+        return base.replace('github.com', 'raw.githubusercontent.com') + `/${branch}`;
+    } else if (strategy === 'gitlab') {
+        return base + `/-/raw/${branch}`;
+    }
+    return base;
+}
+
+async function rollbackOTA() {
+    const targetVersion = process.argv[2];
+    const argChannel = process.argv[3] || 'training';
+
+    if (!targetVersion) {
+        console.log('❌ Error: Mohon tentukan versi tujuan rollback (e.g., npx ota-manager rollback 0.2.0.11 training)');
+        process.exit(1);
+    }
+
+    console.log(`\n🔄 --- MEMULAI PROSES ROLLBACK OTA (${argChannel.toUpperCase()}) ---`);
+    console.log(`🎯 Target Versi : v${targetVersion}`);
+    console.log(`🔹 Strategy     : ${OTA_CONFIG.strategy.toUpperCase()}`);
+
+    try {
+        const config = OTA_CONFIG[OTA_CONFIG.strategy];
+        if (!config || !config.repo) {
+            throw new Error(`Repository not configured for strategy "${OTA_CONFIG.strategy}".`);
+        }
+
+        const channelConfig = config.channels?.[argChannel];
+        const activeBranch = channelConfig?.branch || config.branch || 'main';
+
+        console.log(`📂 Menyiapkan repositori OTA jarak jauh (Branch: ${activeBranch})...`);
+        if (fs.existsSync(OTA_RELEASES_DIR)) {
+            fs.rmSync(OTA_RELEASES_DIR, { recursive: true, force: true });
+        }
+
+        const pat = OTA_CONFIG.strategy === 'gitlab' ? gitlabPat : githubPat;
+        const cloneRepo = config.repo.endsWith('.git') ? config.repo : config.repo + '.git';
+        const authRepo = cloneRepo.replace('https://', `https://${pat}@`);
+
+        execSync(`git clone --branch ${activeBranch} ${authRepo} "${OTA_RELEASES_DIR}"`, { stdio: 'inherit' });
+
+        const zipFileName = `v${targetVersion.replace(/\./g, '_')}.zip`;
+        const zipFilePath = path.join(OTA_RELEASES_DIR, zipFileName);
+
+        console.log(`🔍 Memeriksa ketersediaan bungkusan fisik: ${zipFileName} di server...`);
+        if (!fs.existsSync(zipFilePath)) {
+            console.log(`\n❌ ERROR FATAL: File bungkusan ${zipFileName} TIDAK DITEMUKAN di repositori jarak jauh!`);
+            console.log(`💡 Rollback dibatalkan karena versi tujuan tidak memiliki bungkusan fisik yang valid.`);
+            process.exit(1);
+        }
+        console.log(`✅ File bungkusan fisik ${zipFileName} tersedia dan valid!`);
+
+        const manifestFileName = argChannel === 'training' ? 'manifest-training.json' : 'manifest.json';
+        const manifestPath = path.join(OTA_RELEASES_DIR, manifestFileName);
+
+        const rawBaseUrl = getRawBaseUrl(config.repo, OTA_CONFIG.strategy, activeBranch);
+        const activeOtaUrl = `${rawBaseUrl}/${manifestFileName}`;
+        const activeZipUrl = `${rawBaseUrl}/${zipFileName}`;
+
+        console.log(`📝 Memperbarui ${manifestFileName} jarak jauh ke versi ${targetVersion}...`);
+        const manifest = {
+            version: targetVersion,
+            url: activeZipUrl
+        };
+        fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+
+        console.log(`📝 Memperbarui .env lokal ke versi ${targetVersion}...`);
+        if (fs.existsSync(ENV_PATH)) {
+            let envContent = fs.readFileSync(ENV_PATH, 'utf-8');
+            envContent = envContent.replace(/PUBLIC_APP_VERSION_ANDROID=.*/, `PUBLIC_APP_VERSION_ANDROID=${targetVersion}`);
+            envContent = envContent.replace(/PUBLIC_APP_VERSION_IOS=.*/, `PUBLIC_APP_VERSION_IOS=${targetVersion}`);
+            if (envContent.includes('PUBLIC_APP_VERSION=')) {
+                envContent = envContent.replace(/PUBLIC_APP_VERSION=.*/, `PUBLIC_APP_VERSION=${targetVersion}`);
+            }
+            if (envContent.includes('PUBLIC_OTA_UPDATE_URL=')) {
+                envContent = envContent.replace(/PUBLIC_OTA_UPDATE_URL=.*/, `PUBLIC_OTA_UPDATE_URL=${activeOtaUrl}`);
+            } else {
+                envContent += `\nPUBLIC_OTA_UPDATE_URL=${activeOtaUrl}`;
+            }
+            fs.writeFileSync(ENV_PATH, envContent);
+        }
+
+        if (fs.existsSync(MAIN_MANIFEST_PATH)) {
+            const updateManifest = JSON.parse(fs.readFileSync(MAIN_MANIFEST_PATH, 'utf8'));
+            updateManifest.version = targetVersion;
+            fs.writeFileSync(MAIN_MANIFEST_PATH, JSON.stringify(updateManifest, null, 2));
+        }
+
+        console.log(`📤 Mengirim manifest rollback ke repositori OTA jarak jauh...`);
+        execSync('git add .', { cwd: OTA_RELEASES_DIR, stdio: 'ignore' });
+        execSync(`git commit -m "chore: rollback OTA manifest to v${targetVersion} (${argChannel})"`, { cwd: OTA_RELEASES_DIR, stdio: 'ignore' });
+        execSync(`git push origin ${activeBranch}`, { cwd: OTA_RELEASES_DIR, stdio: 'inherit' });
+
+        console.log(`\n🎉 ROLLBACK SUKSES BERHASIL DIEKSEKUSI!`);
+        console.log(`📄 Versi Aktif Sekarang : v${targetVersion}`);
+        console.log(`🔗 Channel              : ${argChannel}`);
+        console.log(`💡 Capgo di HP pengguna akan langsung mendeteksi manifest baru dan melakukan downgrade otomatis ke v${targetVersion}.\n`);
+
+    } catch (e) {
+        console.error(`\n❌ Rollback Gagal: ${e.message}\n`);
+        process.exit(1);
+    }
+}
+
+rollbackOTA();

package/lib/ota-version.js

@@ -25,10 +25,32 @@ async function checkStatus() {
         return;
     }
 
-    // 1. Get Local Version
+    // 1. Get Local Version & Native Status
     const envContent = fs.readFileSync(ENV_PATH, 'utf-8');
-    const localVersion = envContent.match(/PUBLIC_APP_VERSION_ANDROID=(.*)/)?.[1]?.trim().replace(/^"|"$/g, '');
-    console.log(`💻 Local Version (.env) : v${localVersion || 'unknown'}`);
+    const localVersion = envContent.match(/PUBLIC_APP_VERSION_ANDROID=(.*)/)?.[1]?.trim().replace(/^"|"$/g, '') || envContent.match(/PUBLIC_APP_VERSION=(.*)/)?.[1]?.trim().replace(/^"|"$/g, '');
+    const appId = envContent.match(/PUBLIC_APP_ID=(.*)/)?.[1]?.trim().replace(/^"|"$/g, '') || 'com.cyclopedia.one_eighty_run';
+    console.log(`💻 Local Version (.env) : ${localVersion || 'unknown'}`);
+    console.log(`📦 App ID / Package Name : ${appId}`);
+
+    // Cek Android versionCode
+    const buildGradlePath = path.join(rootDir, 'android', 'app', 'build.gradle');
+    let androidVersionCode = 'unknown';
+    if (fs.existsSync(buildGradlePath)) {
+        const bgContent = fs.readFileSync(buildGradlePath, 'utf8');
+        const match = bgContent.match(/versionCode\s+(\d+)/);
+        if (match) androidVersionCode = match[1];
+    }
+    console.log(`🤖 Android versionCode    : ${androidVersionCode}`);
+
+    // Cek iOS CURRENT_PROJECT_VERSION
+    const pbxprojPath = path.join(rootDir, 'ios', 'App', 'App.xcodeproj', 'project.pbxproj');
+    let iosProjectVersion = 'unknown';
+    if (fs.existsSync(pbxprojPath)) {
+        const pbxContent = fs.readFileSync(pbxprojPath, 'utf8');
+        const match = pbxContent.match(/CURRENT_PROJECT_VERSION = (\d+);/);
+        if (match) iosProjectVersion = match[1];
+    }
+    console.log(`🍏 iOS Project Version    : ${iosProjectVersion}`);
 
     // 2. Get Remote Version based on Config
     const strategy = OTA_CONFIG.strategy;
@@ -83,18 +105,21 @@ async function checkStatus() {
         }
 
         const remoteData = JSON.parse(result);
-        const remoteVersion = remoteData.version;
+        const remoteVersion = remoteData.version || remoteData[channel]?.version;
 
-        if (remoteVersion === localVersion) {
-            console.log(`✅ Status: UP TO DATE (v${remoteVersion})`);
+        if (!remoteVersion) {
+            console.log(`✨ Status: CHANNEL "${channel.toUpperCase()}" KOSONG (Belum ada rilis)`);
+            console.log(`💡 Jalankan 'npm run ota-manager deploy ${channel}' untuk merilis versi perdana ke channel ini!`);
+        } else if (remoteVersion === localVersion) {
+            console.log(`✅ Status: UP TO DATE (${remoteVersion})`);
         } else {
             console.log(`⚠️  Status: OUTDATED!`);
-            console.log(`📡 Remote Version : v${remoteVersion}`);
-            console.log(`💡 Run 'npx ota-updates ${channel}' to update.`);
+            console.log(`📡 Remote Version : ${remoteVersion}`);
+            console.log(`💡 Run 'npm run ota-updates ${channel}' to update.`);
         }
     } catch (e) {
         if (e.message === 'File not found') {
-            console.log(`✨ Status: NEW INFRASTRUCTURE (v0.0.0)`);
+            console.log(`✨ Status: NEW INFRASTRUCTURE (0.0.0)`);
             console.log(`💡 No releases found on server. Ready for initial deployment!`);
         } else {
             console.log(`❌ Could not fetch remote manifest.`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ota-manager",
-  "version": "1.0.7",
+  "version": "1.0.14",
   "description": "Multi-provider OTA update manager for Astro and static web projects.",
   "type": "module",
   "main": "index.js",