ota-manager 1.0.0

package/lib/ota-deploy.js

@@ -0,0 +1,284 @@
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+import OTA_CONFIG from './ota-config.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const rootDir = process.cwd();
+
+const OTA_RELEASES_DIR = path.join(rootDir, 'ota-releases');
+const DIST_DIR = path.join(rootDir, 'dist');
+const ENV_PATH = path.join(rootDir, '.env');
+const MAIN_MANIFEST_PATH = path.join(rootDir, 'src', 'data', 'update-data.json');
+const API_DIR = path.join(rootDir, 'src', 'pages', 'api');
+const API_BACKUP_DIR = path.join(rootDir, 'src', '_api-backup');
+
+const VERIFY_SCRIPT = path.join(__dirname, 'verify-dist.cjs');
+const FLATTEN_SCRIPT = path.join(__dirname, 'flatten-dist.cjs');
+
+function hideApi() {
+    if (fs.existsSync(API_DIR)) {
+        console.log('🙈 Hiding API routes (Using Robust Move)...');
+        try {
+            if (fs.existsSync(API_BACKUP_DIR)) fs.rmSync(API_BACKUP_DIR, { recursive: true, force: true });
+            
+            if (process.platform === 'win32') {
+                try {
+                    execSync(`robocopy "${API_DIR}" "${API_BACKUP_DIR}" /E /MOVE /NFL /NDL /NJH /NJS`, { stdio: 'ignore' });
+                } catch (e) {
+                    if (fs.existsSync(API_DIR)) throw e;
+                }
+            } else {
+                fs.renameSync(API_DIR, API_BACKUP_DIR);
+            }
+            console.log('✅ API routes hidden.');
+        } catch (e) {
+            console.warn(`⚠️  Warning: Could not hide API routes (${e.message}).`);
+        }
+    }
+}
+
+function showApi() {
+    if (fs.existsSync(API_BACKUP_DIR)) {
+        console.log('🐵 Restoring API routes...');
+        try {
+            if (process.platform === 'win32') {
+                try {
+                    execSync(`robocopy "${API_BACKUP_DIR}" "${API_DIR}" /E /MOVE /NFL /NDL /NJH /NJS`, { stdio: 'ignore' });
+                } catch (e) {
+                    if (fs.existsSync(API_BACKUP_DIR)) throw e;
+                }
+            } else {
+                if (fs.existsSync(API_DIR)) fs.rmSync(API_DIR, { recursive: true, force: true });
+                fs.renameSync(API_BACKUP_DIR, API_DIR);
+            }
+            console.log('✅ API routes restored.');
+        } catch (e) {
+            console.error(`❌ Error: Failed to restore API routes: ${e.message}`);
+        }
+    }
+}
+
+const envContent = fs.existsSync(ENV_PATH) ? fs.readFileSync(ENV_PATH, 'utf-8') : '';
+const githubPat = envContent.match(/GITHUB_DEV_PAT=(.*)/)?.[1]?.trim().replace(/^"|"$/g, '') || '';
+const gitlabPat = envContent.match(/GITLAB_DEV_PAT=(.*)/)?.[1]?.trim().replace(/^"|"$/g, '') || '';
+
+const MAX_OTA_SIZE_MB = 50;
+
+function getDirSize(dirPath) {
+    let size = 0;
+    if (!fs.existsSync(dirPath)) return 0;
+    const files = fs.readdirSync(dirPath);
+    for (let i = 0; i < files.length; i++) {
+        const filePath = path.join(dirPath, files[i]);
+        const stats = fs.statSync(filePath);
+        if (stats.isFile()) {
+            size += stats.size;
+        } else if (stats.isDirectory()) {
+            size += getDirSize(filePath);
+        }
+    }
+    return size;
+}
+
+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 deployOTA() {
+    console.log(`🚀 Starting OTA Deployment (Strategy: ${OTA_CONFIG.strategy})...`);
+
+    const argChannel = process.argv[2] || 'training'; 
+    
+    try {
+        if (!fs.existsSync(OTA_RELEASES_DIR)) fs.mkdirSync(OTA_RELEASES_DIR);
+        
+        const config = OTA_CONFIG[OTA_CONFIG.strategy];
+        if (!config || !config.repo) {
+            throw new Error(`Repository not configured for strategy "${OTA_CONFIG.strategy}". Run 'npx ota-updates register ${OTA_CONFIG.strategy}' first.`);
+        }
+        
+        const channelConfig = config.channels?.[argChannel];
+        const activeBranch = channelConfig?.branch || config.branch || 'main';
+
+        console.log(`📂 Preparing ${OTA_CONFIG.strategy} OTA Repository (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' });
+
+        if (!pat) {
+            throw new Error(`Developer PAT for ${OTA_CONFIG.strategy.toUpperCase()} is missing in .env! Run 'npx ota-updates register ${OTA_CONFIG.strategy}' to fix it.`);
+        }
+
+        const currentEnv = fs.readFileSync(ENV_PATH, 'utf-8');
+        const versionMatch = currentEnv.match(/PUBLIC_APP_VERSION_ANDROID=([0-9.]+)/);
+        const currentVersion = versionMatch ? versionMatch[1] : '0.1.9.0';
+
+        let nextVersion = process.argv[3];
+        
+        if (!nextVersion) {
+            console.log('🔍 No version provided, auto-incrementing from remote manifest...');
+            const otaManifestPath = path.join(OTA_RELEASES_DIR, argChannel === 'training' ? 'manifest-training.json' : 'manifest.json');
+            
+            if (fs.existsSync(otaManifestPath)) {
+                const otaManifest = JSON.parse(fs.readFileSync(otaManifestPath, 'utf8'));
+                const latestVersion = otaManifest.version || currentVersion;
+                const parts = latestVersion.split('.');
+                const lastIdx = parts.length - 1;
+                parts[lastIdx] = (parseInt(parts[lastIdx]) + 1).toString();
+                nextVersion = parts.join('.');
+                console.log(`📈 Auto-increment: ${latestVersion} -> ${nextVersion}`);
+            } else {
+                nextVersion = currentVersion;
+                console.log(`⚠️ No remote manifest, using .env version: ${nextVersion}`);
+            }
+        }
+
+        console.log(`📦 Target Version: ${nextVersion} [${argChannel}]`);
+
+        const rawBaseUrl = getRawBaseUrl(config.repo, OTA_CONFIG.strategy, activeBranch);
+        const manifestFileName = argChannel === 'training' ? 'manifest-training.json' : 'manifest.json';
+        const activeOtaUrl = `${rawBaseUrl}/${manifestFileName}`;
+        
+        console.log(`🔗 Auto-Constructing Raw OTA URL: ${activeOtaUrl}`);
+        
+        let updatedEnv = currentEnv;
+        updatedEnv = updatedEnv.replace(/PUBLIC_APP_VERSION_ANDROID=.*/, `PUBLIC_APP_VERSION_ANDROID=${nextVersion}`);
+        updatedEnv = updatedEnv.replace(/PUBLIC_APP_VERSION_IOS=.*/, `PUBLIC_APP_VERSION_IOS=${nextVersion}`);
+        
+        if (updatedEnv.includes('PUBLIC_APP_VERSION=')) {
+            updatedEnv = updatedEnv.replace(/PUBLIC_APP_VERSION=.*/, `PUBLIC_APP_VERSION=${nextVersion}`);
+        }
+        
+        if (updatedEnv.includes('PUBLIC_OTA_UPDATE_URL=')) {
+            updatedEnv = updatedEnv.replace(/PUBLIC_OTA_UPDATE_URL=.*/, `PUBLIC_OTA_UPDATE_URL=${activeOtaUrl}`);
+        } else {
+            updatedEnv += `\nPUBLIC_OTA_UPDATE_URL=${activeOtaUrl}`;
+        }
+        
+        console.log(`📝 Updating .env to version ${nextVersion} (Android & iOS) and setting OTA target...`);
+        fs.writeFileSync(ENV_PATH, updatedEnv);
+        
+        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));
+        }
+
+        console.log('🏗️ Building project for OTA...');
+        hideApi();
+        try {
+            execSync('npm run build', { stdio: 'inherit', cwd: rootDir });
+            
+            if (fs.existsSync(FLATTEN_SCRIPT)) {
+                console.log('🚀 Running Tsar Bomba Path Cleanse...');
+                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);
+        const distSizeMB = distSizeBytes / (1024 * 1024);
+        console.log(`📊 Estimated Size: ${distSizeMB.toFixed(2)} MB`);
+
+        if (distSizeMB > MAX_OTA_SIZE_MB) {
+            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 otaPath = path.join(rootDir, otaName);
+
+        const isWindows = process.platform === 'win32';
+        const tarCmd = isWindows ? 'tar.exe' : 'tar';
+        const zipCmd = `${tarCmd} -a -c -f "${otaPath}" -C "${DIST_DIR}" .`;
+        
+        execSync(zipCmd, { stdio: 'inherit' });
+
+        console.log('🛡️  Verifying ZIP Integrity...');
+        try {
+            execSync(`${tarCmd} -t -f "${otaPath}"`, { stdio: 'ignore' });
+            console.log('✅ ZIP is valid and readable.');
+        } catch (e) {
+            throw new Error('CRITICAL: Generated ZIP is corrupt or invalid!');
+        }
+
+        const zipStats = fs.statSync(otaPath);
+        const zipSizeMB = zipStats.size / (1024 * 1024);
+        console.log(`📊 Final ZIP Size: ${zipSizeMB.toFixed(2)} MB`);
+
+        if (zipSizeMB > MAX_OTA_SIZE_MB) {
+            if (fs.existsSync(otaPath)) fs.unlinkSync(otaPath);
+            throw new Error(`CRITICAL SIZE VIOLATION: ZIP file bloated to ${zipSizeMB.toFixed(2)} MB! Deployment aborted!`);
+        }
+
+        await deployToRemote(otaPath, otaName, nextVersion, argChannel, activeBranch);
+
+        console.log(`\n✅ OTA DEPLOY SUCCESS!`);
+        console.log(`📄 Version: ${nextVersion}`);
+        console.log(`🔗 Channel: ${argChannel}\n`);
+
+    } catch (error) {
+        console.error(`\n❌ Deployment Failed: ${error.message}\n`);
+        process.exit(1);
+    } finally {
+        showApi();
+    }
+}
+
+async function deployToRemote(otaPath, otaName, version, channel, branch) {
+    const config = OTA_CONFIG[OTA_CONFIG.strategy];
+    const pat = OTA_CONFIG.strategy === 'gitlab' ? gitlabPat : githubPat;
+    console.log(`🚀 Pushing to ${OTA_CONFIG.strategy} (Branch: ${branch})...`);
+    
+    const targetPath = path.join(OTA_RELEASES_DIR, otaName);
+    fs.copyFileSync(otaPath, targetPath);
+
+    const manifestPath = path.join(OTA_RELEASES_DIR, 'manifest.json');
+    let manifest = { live: {}, training: {} };
+    if (fs.existsSync(manifestPath)) {
+        manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+    }
+
+    const rawBaseUrl = getRawBaseUrl(config.repo, OTA_CONFIG.strategy, branch);
+    manifest[channel] = {
+        version,
+        url: `${rawBaseUrl}/${otaName}`,
+        date: new Date().toISOString(),
+        note: `Update to ${version} (${channel})`
+    };
+
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+
+    const flatManifestPath = path.join(OTA_RELEASES_DIR, `manifest-${channel}.json`);
+    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 push origin ${branch}`, { cwd: OTA_RELEASES_DIR });
+
+    if (fs.existsSync(otaPath)) fs.unlinkSync(otaPath);
+}
+
+deployOTA();

package/lib/ota-main.js

@@ -0,0 +1,197 @@
+import { execSync } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import fs from 'fs';
+import OTA_CONFIG from './ota-config.js';
+import { listConfigs, useConfig, registerConfig, testConnection } from './ota-manager.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const rootDir = process.cwd();
+
+const command = process.argv[2];
+const subArg = process.argv[3];
+const versionArg = process.argv[4];
+
+const TOOL_VERSION = '1.2.0';
+
+const scripts = {
+    version: path.join(__dirname, 'ota-version.js'),
+    deploy: path.join(__dirname, 'ota-deploy.js'),
+    verify: path.join(__dirname, 'verify-dist.cjs'),
+    security: path.join(__dirname, 'ota-security.js'),
+    build: path.join(__dirname, 'ota-build.cjs'),
+};
+
+function showHelp() {
+    console.log(`
+╔════════════════════════════════════════════════════════════╗
+║                        OTA MANAGER                         ║
+║                        Version ${TOOL_VERSION}                       ║
+╚════════════════════════════════════════════════════════════╝
+
+Usage: npx ota-updates <command> [sub-command] [version]
+
+Management Commands:
+  list      : Show all registered infrastructures.
+  use <id>  : Set default infrastructure (e.g., use gitlab).
+  register <id> : Register or update infrastructure (e.g., register s3).
+  verify    : Verify active infrastructure connectivity.
+  audit     : Audit public token for security leaks.
+  test      : Run E2E simulation (Push & Read).
+
+Operational Commands:
+  status    : Check local vs remote version.
+  training  : Deploy update to TRAINING channel.
+  live      : Deploy update to LIVE channel.
+
+Active Infrastructure:
+  Strategy : ${OTA_CONFIG.strategy.toUpperCase()}
+  Repo     : ${OTA_CONFIG[OTA_CONFIG.strategy]?.repo || 'Not Configured'}
+──────────────────────────────────────────────────────────────
+    `);
+}
+
+import readline from 'readline';
+
+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');
+        });
+    });
+}
+
+async function run() {
+    try {
+        switch (command) {
+            case 'list':
+                await listConfigs();
+                process.exit(0);
+                break;
+
+            case 'use':
+                if (!subArg) {
+                    console.log('❌ Error: Please specify the infrastructure ID (e.g., use gitlab).');
+                    process.exit(1);
+                }
+                await useConfig(subArg);
+                process.exit(0);
+                break;
+
+            case 'register':
+                if (!subArg) {
+                    console.log('❌ Error: Please specify the ID (e.g., register gitlab).');
+                    process.exit(1);
+                }
+                await registerConfig(subArg);
+                process.exit(0);
+                break;
+
+            case 'help':
+            case '-h':
+            case '--help':
+                showHelp();
+                process.exit(0);
+                break;
+
+            case '-v':
+            case '--version':
+                console.log(`OTA Manager v${TOOL_VERSION}`);
+                process.exit(0);
+                break;
+
+            case 'status':
+            case 'version':
+                execSync(`node "${scripts.version}"`, { stdio: 'inherit' });
+                process.exit(0);
+                break;
+
+            case 'verify':
+                execSync(`node "${scripts.verify}"`, { stdio: 'inherit' });
+                process.exit(0);
+                break;
+
+            case 'test':
+                await testConnection();
+                process.exit(0);
+                break;
+
+            case 'build':
+                execSync(`node "${scripts.build}" ${subArg || ''}`, { stdio: 'inherit' });
+                process.exit(0);
+                break;
+
+            case 'audit':
+            case 'security-check':
+            case 'security':
+                execSync(`node "${scripts.security}"`, { stdio: 'inherit' });
+                process.exit(0);
+                break;
+
+            case 'training':
+                execSync(`node "${scripts.version}"`, { stdio: 'inherit' });
+                execSync(`node "${scripts.verify}"`, { stdio: 'inherit' });
+                
+                console.log(`\n📋 DEPLOYMENT PLAN [TRAINING]`);
+                console.log(`🔹 Infra   : ${OTA_CONFIG.strategy.toUpperCase()}`);
+                console.log(`🔹 Action  : Build & Push to Training Channel`);
+                
+                if (await confirm('Proceed with TRAINING deployment?')) {
+                    execSync(`node "${scripts.deploy}" training ${subArg || ''}`, { stdio: 'inherit' });
+                } else {
+                    console.log('❌ Deployment cancelled.');
+                }
+                process.exit(0);
+                break;
+
+            case 'live':
+                execSync(`node "${scripts.version}"`, { stdio: 'inherit' });
+                execSync(`node "${scripts.verify}"`, { stdio: 'inherit' });
+                
+                console.log(`\n🚨 WARNING: DEPLOYMENT KE LIVE [PRODUCTION]`);
+                console.log(`🔹 Infra   : ${OTA_CONFIG.strategy.toUpperCase()}`);
+                console.log(`🔹 Action  : Build & Push to LIVE Channel`);
+                
+                if (await confirm('ARE YOU SURE you want to deploy to LIVE?')) {
+                    execSync(`node "${scripts.deploy}" live ${subArg || ''}`, { stdio: 'inherit' });
+                } else {
+                    console.log('❌ LIVE Deployment cancelled.');
+                }
+                process.exit(0);
+                break;
+
+            case 'deploy':
+                if (!subArg) {
+                    console.log('❌ Error: Mohon tentukan channel (training/live).');
+                    process.exit(1);
+                }
+                
+                execSync(`node "${scripts.verify}"`, { stdio: 'inherit' });
+                
+                if (await confirm(`Deploy to ${subArg.toUpperCase()}?`)) {
+                    execSync(`node "${scripts.deploy}" ${subArg} ${versionArg || ''}`, { stdio: 'inherit' });
+                } else {
+                    console.log('❌ Deployment cancelled.');
+                }
+                process.exit(0);
+                break;
+
+            default:
+                console.log(`\n❓ Unknown command: "${command || ''}"`);
+                showHelp();
+                process.exit(0);
+                break;
+        }
+    } catch (error) {
+        console.log(`\n❌ Process stopped due to error or cancellation.`);
+        process.exit(1);
+    }
+}
+
+run();

package/lib/ota-manager.js

@@ -0,0 +1,207 @@
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import readline from 'readline';
+
+const rootDir = process.cwd();
+const configJsonPath = path.join(rootDir, 'ota-config.json');
+const ENV_PATH = path.join(rootDir, '.env');
+
+function question(query) {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        rl.question(query, (answer) => {
+            rl.close();
+            resolve(answer);
+        });
+    });
+}
+
+export async function listConfigs() {
+    if (!fs.existsSync(configJsonPath)) {
+        console.log(`\n❌ Error: ota-config.json not found in ${rootDir}`);
+        console.log(`💡 Please run 'npx ota-updates register github' to initialize.`);
+        return;
+    }
+    const config = JSON.parse(fs.readFileSync(configJsonPath, 'utf-8'));
+    const envContent = fs.existsSync(ENV_PATH) ? fs.readFileSync(ENV_PATH, 'utf-8') : '';
+    
+    console.log(`\n📋 --- REGISTERED OTA INFRASTRUCTURE ---`);
+    console.log(`   ${"[ ID ]".padEnd(8)} | ${"[ STATUS ]".padEnd(14)} | [ REPOSITORY URL ]`);
+    console.log(`   ${"--------".padEnd(8)} | ${"------------".padEnd(14)} | ------------------`);
+    
+    for (const key of Object.keys(config.configs)) {
+        const isDefault = config.strategy === key;
+        const icon = isDefault ? '⭐️' : '  ';
+        const repo = config.configs[key].repo;
+        
+        // Validation Check
+        const pubVar = `PUBLIC_${key.toUpperCase()}_OTA_PAT`;
+        const devVar = `${key.toUpperCase()}_DEV_PAT`;
+        const hasPub = envContent.includes(`${pubVar}=`) && envContent.match(new RegExp(`${pubVar}=(.*)`))?.[1]?.trim().length > 0;
+        const hasDev = envContent.includes(`${devVar}=`) && envContent.match(new RegExp(`${devVar}=(.*)`))?.[1]?.trim().length > 0;
+        
+        let status = '';
+        if (hasPub && hasDev && repo) {
+            status = '✅ [READY]';
+        } else {
+            status = '⚠️  [INCOMPLETE]';
+        }
+
+        console.log(`${icon} ${key.toUpperCase().padEnd(8)} : ${status.padEnd(14)} | ${repo}`);
+    }
+    
+    console.log(`\n⭐️ = Active Strategy`);
+    console.log(`💡 Use 'npx ota-updates register <id>' to complete configuration.`);
+    console.log(`💡 Use 'npx ota-updates use <id>' to switch connection.`);
+    console.log(`------------------------------------------\n`);
+}
+
+export async function useConfig(strategy) {
+    if (!fs.existsSync(configJsonPath)) {
+        console.log(`\n❌ Error: ota-config.json not found in ${rootDir}`);
+        return;
+    }
+    const config = JSON.parse(fs.readFileSync(configJsonPath, 'utf-8'));
+    if (!config.configs[strategy]) {
+        console.log(`❌ Error: Strategy "${strategy}" is not registered.`);
+        return;
+    }
+    config.strategy = strategy;
+    fs.writeFileSync(configJsonPath, JSON.stringify(config, null, 2));
+    console.log(`✅ Default strategy successfully changed to: ${strategy.toUpperCase()}`);
+}
+
+export async function registerConfig(strategy) {
+    let config = { strategy: strategy, configs: {} };
+    if (fs.existsSync(configJsonPath)) {
+        config = JSON.parse(fs.readFileSync(configJsonPath, 'utf-8'));
+    }
+    
+    if (config.configs[strategy]) {
+        const confirm = await question(`⚠️  Strategy "${strategy}" already exists. Rewrite? [y/N]: `);
+        if (confirm.toLowerCase() !== 'y') {
+            console.log('❌ Registration cancelled.');
+            return;
+        }
+    }
+
+    console.log(`\n📝 INFRASTRUCTURE REGISTRATION: ${strategy.toUpperCase()}`);
+    const repo = await question(`🔹 Enter Repo URL: `);
+    const pubPat = await question(`🔹 Enter PUBLIC PAT (Read-only): `);
+    const devPat = await question(`🔹 Enter DEVELOPER PAT (Write): `);
+
+    // Update JSON
+    config.configs[strategy] = {
+        repo: repo.replace(/\/$/, ''),
+        branch: 'main',
+        channels: {
+            live: { branch: 'main' },
+            training: { branch: 'main' }
+        }
+    };
+    fs.writeFileSync(configJsonPath, JSON.stringify(config, null, 2));
+
+    // Update .env
+    let envContent = fs.existsSync(ENV_PATH) ? fs.readFileSync(ENV_PATH, 'utf-8') : '';
+    const pubVar = `PUBLIC_${strategy.toUpperCase()}_OTA_PAT`;
+    const devVar = `${strategy.toUpperCase()}_DEV_PAT`;
+
+    // Replace or Append Public PAT
+    if (envContent.includes(`${pubVar}=`)) {
+        envContent = envContent.replace(new RegExp(`${pubVar}=.*`), `${pubVar}=${pubPat}`);
+    } else {
+        envContent += `\n${pubVar}=${pubPat}`;
+    }
+
+    // Replace or Append Dev PAT
+    if (envContent.includes(`${devVar}=`)) {
+        envContent = envContent.replace(new RegExp(`${devVar}=.*`), `${devVar}=${devPat}`);
+    } else {
+        envContent += `\n${devVar}=${devPat}`;
+    }
+
+    fs.writeFileSync(ENV_PATH, envContent.trim() + '\n');
+    
+    console.log(`\n✅ Registration for ${strategy.toUpperCase()} Successful!`);
+    console.log(`💡 Run 'npx ota-updates use ${strategy}' to activate it.`);
+}
+
+export async function testConnection() {
+    if (!fs.existsSync(configJsonPath)) {
+        console.log(`\n❌ Error: ota-config.json not found in ${rootDir}`);
+        return;
+    }
+    const config = JSON.parse(fs.readFileSync(configJsonPath, 'utf-8'));
+    const strategy = config.strategy;
+    const activeConfig = config.configs[strategy];
+    const envContent = fs.existsSync(ENV_PATH) ? fs.readFileSync(ENV_PATH, 'utf-8') : '';
+    
+    // Load Tokens
+    const githubDev = envContent.match(/GITHUB_DEV_PAT=(.*)/)?.[1]?.trim();
+    const gitlabDev = envContent.match(/GITLAB_DEV_PAT=(.*)/)?.[1]?.trim();
+    const githubPub = envContent.match(/PUBLIC_GITHUB_OTA_PAT=(.*)/)?.[1]?.trim();
+    const gitlabPub = envContent.match(/PUBLIC_GITLAB_OTA_PAT=(.*)/)?.[1]?.trim();
+    
+    const devPat = strategy === 'gitlab' ? gitlabDev : githubDev;
+    const pubPat = strategy === 'gitlab' ? gitlabPub : githubPub;
+
+    // --- PRE-FLIGHT CHECK ---
+    if (!devPat || !pubPat) {
+        console.log(`\n❌ Error: Missing configuration for ${strategy.toUpperCase()}`);
+        console.log(`💡 Please run 'npx ota-updates register ${strategy}' to set up your PATs first.`);
+        return;
+    }
+
+    console.log(`\n🧪 --- E2E CONNECTION SIMULATION (${strategy.toUpperCase()}) ---`);
+    const otaReleasesDir = path.join(rootDir, 'ota-releases');
+    const cloneRepo = activeConfig.repo.endsWith('.git') ? activeConfig.repo : activeConfig.repo + '.git';
+    
+    // GitLab needs 'oauth2' prefix
+    const authRepo = strategy === 'gitlab' 
+        ? cloneRepo.replace('https://', `https://oauth2:${devPat}@`) 
+        : cloneRepo.replace('https://', `https://${devPat}@`);
+
+    const tempDir = path.join(rootDir, 'temp-e2e-test');
+    if (fs.existsSync(tempDir)) fs.rmSync(tempDir, { recursive: true, force: true });
+
+    try {
+        console.log(`1️⃣  Testing DEVELOPER PAT (Push Access)...`);
+        execSync(`git clone --depth 1 "${authRepo}" "${tempDir}"`, { stdio: 'ignore' });
+        console.log(`   ✅ Developer PAT: Valid (Clone/Push Access OK)`);
+
+        console.log(`2️⃣  Testing PUBLIC PAT (Read Access)...`);
+        let fetchUrl = `${activeConfig.repo}/manifest.json`;
+        let authHeader = `Authorization: Bearer ${pubPat}`;
+
+        if (strategy === 'github') {
+            const repoPath = activeConfig.repo.replace('https://github.com/', '').replace(/\/$/, '');
+            fetchUrl = `https://api.github.com/repos/${repoPath}/contents/manifest.json`;
+            authHeader = `Authorization: Bearer ${pubPat}`;
+        } else if (strategy === 'gitlab') {
+            const projectId = '82216532';
+            fetchUrl = `https://gitlab.com/api/v4/projects/${projectId}/repository/files/manifest.json/raw?ref=main`;
+            authHeader = pubPat.startsWith('gldt-') ? `Deploy-Token: ${pubPat}` : `Authorization: Bearer ${pubPat}`;
+        }
+
+        const curlAuth = `-H "${authHeader}"`;
+        const cmd = `curl.exe -sL -A "Mozilla/5.0" ${curlAuth} "${fetchUrl}"`;
+        const result = execSync(cmd).toString().trim();
+
+        if (result.includes('404') || result.includes('403') || result.includes('Not Found') || result.includes('Forbidden')) {
+            console.log(`   ⚠️  Public PAT connected but file not found (Expected for new repo)`);
+        } else {
+            console.log(`   ✅ Public PAT: Valid (Read Access OK)`);
+        }
+
+        console.log(`\n🎉 E2E SIMULATION SUCCESS! Your infrastructure is 100% ready.\n`);
+    } catch (e) {
+        console.log(`\n❌ E2E Simulation Failed: ${e.message}`);
+        console.log(`💡 Please verify your repository URL and PAT permissions.`);
+    } finally {
+        if (fs.existsSync(tempDir)) fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+}