"use strict"; /** * Mobile app release lifecycle: admin CRUD, APK validation, public check/download, telemetry. */ var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { if (k2 === undefined) k2 = k; var desc = Object.getOwnPropertyDescriptor(m, k); if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { desc = { enumerable: true, get: function() { return m[k]; } }; } Object.defineProperty(o, k2, desc); }) : (function(o, m, k, k2) { if (k2 === undefined) k2 = k; o[k2] = m[k]; })); var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { Object.defineProperty(o, "default", { enumerable: true, value: v }); }) : function(o, v) { o["default"] = v; }); var __importStar = (this && this.__importStar) || (function () { var ownKeys = function(o) { ownKeys = Object.getOwnPropertyNames || function (o) { var ar = []; for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; return ar; }; return ownKeys(o); }; return function (mod) { if (mod && mod.__esModule) return mod; var result = {}; if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); __setModuleDefault(result, mod); return result; }; })(); var __importDefault = (this && this.__importDefault) || function (mod) { return (mod && mod.__esModule) ? mod : { "default": mod }; }; Object.defineProperty(exports, "__esModule", { value: true }); exports.MobileReleaseError = void 0; exports.rolloutBucket = rolloutBucket; exports.isRolloutEligible = isRolloutEligible; exports.hashDeviceId = hashDeviceId; exports.createDownloadToken = createDownloadToken; exports.verifyDownloadToken = verifyDownloadToken; exports.getLatestPublicAndroidApk = getLatestPublicAndroidApk; exports.getSettings = getSettings; exports.updateSettings = updateSettings; exports.listReleases = listReleases; exports.getRelease = getRelease; exports.createRelease = createRelease; exports.updateReleaseMeta = updateReleaseMeta; exports.attachApk = attachApk; exports.submitForValidation = submitForValidation; exports.publish = publish; exports.suspend = suspend; exports.retire = retire; exports.hardDelete = hardDelete; exports.checkAndroidUpdate = checkAndroidUpdate; exports.openDownloadStream = openDownloadStream; exports.recordClientEvent = recordClientEvent; exports.getStats = getStats; exports.evaluateClientVersionGate = evaluateClientVersionGate; const crypto_1 = __importDefault(require("crypto")); const fs_1 = __importDefault(require("fs")); const path_1 = __importDefault(require("path")); const config_1 = require("../config"); const httpError_1 = require("../utils/httpError"); const apkParser_1 = require("../utils/apkParser"); const virusScanService_1 = require("./virusScanService"); const apkStorageService_1 = require("./apkStorageService"); const repo = __importStar(require("../repositories/mobileAppReleaseRepository")); const fileIntegrityService_1 = require("./fileIntegrityService"); const fileIntegrityRepository = __importStar(require("../repositories/fileIntegrityRepository")); const auditLogRepository = __importStar(require("../repositories/auditLogRepository")); class MobileReleaseError extends httpError_1.HttpError { constructor(status, message, code) { super(status, message, code); this.name = 'MobileReleaseError'; } } exports.MobileReleaseError = MobileReleaseError; /** Deterministic rollout bucket 0–99 from device id. */ function rolloutBucket(deviceId) { const hash = crypto_1.default.createHash('sha256').update(String(deviceId || 'anonymous')).digest(); return hash.readUInt32BE(0) % 100; } function isRolloutEligible(deviceId, rolloutPercent) { if (rolloutPercent >= 100) return true; if (rolloutPercent <= 0) return false; return rolloutBucket(deviceId) < rolloutPercent; } function hashDeviceId(deviceId) { return crypto_1.default.createHash('sha256').update(`tloto-device:${deviceId}`).digest('hex').slice(0, 32); } function signDownloadToken(releaseId, exp) { const payload = `${releaseId}.${exp}`; const sig = crypto_1.default .createHmac('sha256', config_1.config.mobileReleases.downloadTokenSecret) .update(payload) .digest('base64url'); return `${payload}.${sig}`; } function createDownloadToken(releaseId) { const expiresAt = Math.floor(Date.now() / 1000) + config_1.config.mobileReleases.downloadTokenTtlSeconds; return { token: signDownloadToken(releaseId, expiresAt), expiresAt }; } function verifyDownloadToken(token, releaseId) { const parts = token.split('.'); if (parts.length !== 3) return false; const [id, expStr, sig] = parts; if (id !== releaseId) return false; const exp = parseInt(expStr, 10); if (!Number.isFinite(exp) || exp < Math.floor(Date.now() / 1000)) return false; const expected = signDownloadToken(releaseId, exp); try { return crypto_1.default.timingSafeEqual(Buffer.from(token), Buffer.from(expected)); } catch { return false; } } function publicDownloadPath(releaseId, token) { const api = config_1.config.apiPrefix.replace(/\/$/, ''); return `${api}/app-updates/android/download/${releaseId}?token=${encodeURIComponent(token)}`; } function publicDownloadUrl(releaseId, token) { const base = config_1.config.app.publicUrl.replace(/\/$/, ''); return `${base}${publicDownloadPath(releaseId, token)}`; } /** Latest published Android APK for the public website (ignores staged rollout). */ async function getLatestPublicAndroidApk(channel = 'production') { const latest = await repo.findLatestPublished('android', channel); if (!latest || !latest.storageKey || !latest.sha256) { return { available: false, versionName: null, versionCode: null, fileSizeBytes: null, sha256: null, downloadUrl: null, downloadPath: null, publishedAt: null, packageName: null, }; } const { token } = createDownloadToken(latest.id); return { available: true, versionName: latest.versionName, versionCode: latest.versionCode, fileSizeBytes: latest.fileSizeBytes, sha256: latest.sha256, downloadUrl: publicDownloadUrl(latest.id, token), downloadPath: publicDownloadPath(latest.id, token), publishedAt: latest.publishedAt?.toISOString() ?? null, packageName: latest.packageName, }; } async function getSettings() { return repo.getSettings(); } async function updateSettings(input) { return repo.updateSettings(input); } async function listReleases(filters) { return repo.listReleases(filters); } async function getRelease(id) { const release = await repo.findById(id); if (!release) throw new MobileReleaseError(404, 'Release not found'); return release; } async function createRelease(input) { if (input.platform === 'ios') { throw new MobileReleaseError(400, 'iOS IPA distribution is not supported; use App Store / TestFlight'); } try { return await repo.createRelease({ platform: 'android', channel: input.channel ?? 'production', versionName: input.versionName, versionCode: input.versionCode, previousVersionName: input.previousVersionName, whatsNew: input.whatsNew, bugFixes: input.bugFixes, updatePolicy: input.updatePolicy, rolloutPercent: input.rolloutPercent, createdBy: input.createdBy, }); } catch (e) { const msg = e instanceof Error ? e.message : String(e); if (/unique|duplicate/i.test(msg)) { throw new MobileReleaseError(409, 'A release with this versionCode already exists for the channel'); } throw e; } } async function updateReleaseMeta(id, patch) { const existing = await getRelease(id); if (existing.status === 'retired') { throw new MobileReleaseError(400, 'Retired releases cannot be edited'); } const updated = await repo.updateRelease(id, patch); if (!updated) throw new MobileReleaseError(404, 'Release not found'); return updated; } async function attachApk(id, uploadedAbsolutePath) { const release = await getRelease(id); if (!['draft', 'pending_validation', 'suspended'].includes(release.status)) { throw new MobileReleaseError(400, 'APK can only be uploaded for draft, pending, or suspended releases'); } const stat = fs_1.default.statSync(uploadedAbsolutePath); if (stat.size > (0, apkStorageService_1.getApkMaxUploadBytes)()) { (0, apkStorageService_1.removeApkIfExists)(`staging/${path_1.default.basename(uploadedAbsolutePath)}`); throw new MobileReleaseError(400, 'APK exceeds maximum upload size'); } try { await (0, virusScanService_1.scanUploadedFile)(uploadedAbsolutePath); } catch (e) { (0, apkStorageService_1.removeApkIfExists)(`staging/${path_1.default.basename(uploadedAbsolutePath)}`); throw new MobileReleaseError(422, e instanceof Error ? e.message : 'Virus scan failed'); } let parsed; try { parsed = await (0, apkParser_1.parseApkFile)(uploadedAbsolutePath); } catch (e) { (0, apkStorageService_1.removeApkIfExists)(`staging/${path_1.default.basename(uploadedAbsolutePath)}`); throw new MobileReleaseError(400, e instanceof Error ? e.message : 'Invalid APK'); } const settings = await repo.getSettings(); const expectedPackage = config_1.config.mobileReleases.expectedPackage || settings.expectedPackageName; if (parsed.packageName !== expectedPackage) { (0, apkStorageService_1.removeApkIfExists)(`staging/${path_1.default.basename(uploadedAbsolutePath)}`); throw new MobileReleaseError(400, `APK package "${parsed.packageName}" does not match expected "${expectedPackage}"`); } // Draft/pending: adopt APK versionCode/name when they differ (admin often mistypes the form). let nextVersionCode = release.versionCode; if (parsed.versionCode !== release.versionCode) { const conflict = await repo.findByPlatformChannelVersionCode(release.platform, release.channel, parsed.versionCode); if (conflict && conflict.id !== release.id) { (0, apkStorageService_1.removeApkIfExists)(`staging/${path_1.default.basename(uploadedAbsolutePath)}`); throw new MobileReleaseError(409, `APK versionCode ${parsed.versionCode} is already used by another release (${conflict.versionName})`); } nextVersionCode = parsed.versionCode; } const expectedCert = config_1.config.mobileReleases.expectedCertSha256; if (expectedCert) { if (!parsed.signingCertSha256) { (0, apkStorageService_1.removeApkIfExists)(`staging/${path_1.default.basename(uploadedAbsolutePath)}`); throw new MobileReleaseError(400, 'Could not read APK signing certificate'); } if (parsed.signingCertSha256.toLowerCase() !== expectedCert) { (0, apkStorageService_1.removeApkIfExists)(`staging/${path_1.default.basename(uploadedAbsolutePath)}`); throw new MobileReleaseError(400, 'APK signing certificate does not match the expected fingerprint'); } } if (release.storageKey) (0, apkStorageService_1.removeApkIfExists)(release.storageKey); const stagingKey = `staging/${path_1.default.basename(uploadedAbsolutePath)}`; const fileSha = await (0, apkStorageService_1.sha256File)(uploadedAbsolutePath); const updated = await repo.updateRelease(id, { packageName: parsed.packageName, versionName: parsed.versionName || release.versionName, versionCode: nextVersionCode, storageKey: stagingKey, fileSizeBytes: stat.size, sha256: fileSha, signingCertSha256: parsed.signingCertSha256, status: release.status === 'draft' ? 'pending_validation' : release.status, }); if (!updated) throw new MobileReleaseError(404, 'Release not found'); return updated; } async function submitForValidation(id) { const release = await getRelease(id); if (!release.storageKey || !release.sha256) { throw new MobileReleaseError(400, 'Upload an APK before submitting for validation'); } if (release.status !== 'draft' && release.status !== 'pending_validation') { throw new MobileReleaseError(400, 'Only draft releases can be submitted'); } const updated = await repo.updateRelease(id, { status: 'pending_validation' }); if (!updated) throw new MobileReleaseError(404, 'Release not found'); return updated; } async function publish(id) { const release = await getRelease(id); if (!['pending_validation', 'suspended', 'draft'].includes(release.status)) { throw new MobileReleaseError(400, 'Release cannot be published from its current status'); } if (!release.storageKey || !release.sha256 || !release.fileSizeBytes) { throw new MobileReleaseError(400, 'APK file is required before publication'); } const settings = await repo.getSettings(); const expectedPackage = config_1.config.mobileReleases.expectedPackage || settings.expectedPackageName; if (release.packageName && release.packageName !== expectedPackage) { throw new MobileReleaseError(400, 'Package name mismatch — re-upload the APK'); } const expectedCert = config_1.config.mobileReleases.expectedCertSha256; if (expectedCert && release.signingCertSha256?.toLowerCase() !== expectedCert) { throw new MobileReleaseError(400, 'Signing certificate fingerprint mismatch'); } const latest = await repo.findLatestPublished(release.platform, release.channel); if (latest && latest.versionCode >= release.versionCode && latest.id !== release.id) { throw new MobileReleaseError(400, `versionCode must be strictly greater than the current published release (${latest.versionCode})`); } let storageKey = release.storageKey; if (storageKey.startsWith('staging/')) { storageKey = (0, apkStorageService_1.moveApkToPublished)(storageKey, release.id); try { await (0, fileIntegrityService_1.recordUploadedFile)(fileIntegrityService_1.FILE_INTEGRITY_ROOTS.apkPublished, `${release.id}.apk`); } catch (e) { console.warn('[mobile-releases] FIM baseline skipped:', e); } } const updated = await repo.updateRelease(id, { storageKey, status: 'published', publishedAt: new Date(), }); if (!updated) throw new MobileReleaseError(404, 'Release not found'); return updated; } async function suspend(id) { const release = await getRelease(id); if (release.status !== 'published') { throw new MobileReleaseError(400, 'Only published releases can be suspended'); } const updated = await repo.updateRelease(id, { status: 'suspended' }); if (!updated) throw new MobileReleaseError(404, 'Release not found'); return updated; } async function retire(id) { const release = await getRelease(id); if (release.status === 'retired') return release; const updated = await repo.updateRelease(id, { status: 'retired' }); if (!updated) throw new MobileReleaseError(404, 'Release not found'); return updated; } /** * Permanently deletes a release: APK file on disk, FIM snapshot, events, DB row. * Blocks deletion of the current highest published release for that platform/channel * (would leave clients without an update target). */ async function hardDelete(id, actor) { const release = await getRelease(id); if (release.status === 'published') { const latest = await repo.findLatestPublished(release.platform, release.channel); if (latest && latest.id === release.id) { throw new MobileReleaseError(400, 'Cannot delete the current published release. Publish a newer build first, or suspend/retire this one.', 'MOBILE_RELEASE_IS_LATEST_PUBLISHED'); } } const storageKey = release.storageKey; const eventsRemoved = await repo.deleteEventsForRelease(id); const deleted = await repo.deleteRelease(id); if (!deleted) throw new MobileReleaseError(404, 'Release not found'); (0, apkStorageService_1.removeApkIfExists)(storageKey); if (storageKey?.startsWith('published/')) { try { await fileIntegrityRepository.deleteSnapshot(fileIntegrityService_1.FILE_INTEGRITY_ROOTS.apkPublished, `${id}.apk`); } catch (e) { console.warn('[mobile-releases] FIM snapshot cleanup skipped:', e); } } if (actor?.userId) { await auditLogRepository.create({ userId: actor.userId, action: 'mobile_release_deleted', resourceType: 'mobile_app_release', resourceId: id, ipAddress: actor.ipAddress ?? null, userAgent: actor.userAgent ?? null, metadata: { versionName: release.versionName, versionCode: release.versionCode, status: release.status, storageKey, eventsRemoved, }, }); } return { deleted: true, versionCode: release.versionCode, versionName: release.versionName, }; } async function checkAndroidUpdate(input) { const channel = input.channel ?? 'production'; const settings = await repo.getSettings(); const latest = await repo.findLatestPublished('android', channel); const mandatory = await repo.findHighestMandatoryPublished('android', channel); const minSupported = settings.minSupportedVersionCode; const blocked = input.versionCode < minSupported; await repo.insertEvent({ releaseId: latest?.id ?? null, eventType: 'check', platform: 'android', channel, clientVersionCode: input.versionCode, deviceIdHash: hashDeviceId(input.deviceId), }); const base = { updateAvailable: false, blocked, policy: null, versionName: null, versionCode: null, whatsNew: null, bugFixes: null, fileSizeBytes: null, sha256: null, downloadUrl: null, downloadPath: null, minSupportedVersionCode: minSupported, checkIntervalSeconds: settings.checkIntervalSeconds, publishedAt: null, packageName: settings.expectedPackageName, }; if (!latest || latest.versionCode <= input.versionCode) { return base; } if (!isRolloutEligible(input.deviceId, latest.rolloutPercent)) { return base; } const { token } = createDownloadToken(latest.id); let policy = latest.updatePolicy; if (mandatory && mandatory.versionCode > input.versionCode) { policy = 'mandatory'; } if (blocked) policy = 'mandatory'; return { ...base, updateAvailable: true, policy, versionName: latest.versionName, versionCode: latest.versionCode, whatsNew: latest.whatsNew, bugFixes: latest.bugFixes, fileSizeBytes: latest.fileSizeBytes, sha256: latest.sha256, downloadUrl: publicDownloadUrl(latest.id, token), downloadPath: publicDownloadPath(latest.id, token), publishedAt: latest.publishedAt?.toISOString() ?? null, packageName: latest.packageName, }; } async function openDownloadStream(releaseId, token) { if (!verifyDownloadToken(token, releaseId)) { throw new MobileReleaseError(403, 'Invalid or expired download token'); } const release = await getRelease(releaseId); if (release.status !== 'published' || !release.storageKey) { throw new MobileReleaseError(404, 'Release is not available for download'); } const absolutePath = (0, apkStorageService_1.resolveApkStoragePath)(release.storageKey); if (!fs_1.default.existsSync(absolutePath)) { throw new MobileReleaseError(404, 'APK file missing on server'); } await repo.insertEvent({ releaseId, eventType: 'download_start', platform: release.platform, channel: release.channel, }); await repo.incrementCounter(releaseId, 'download_count'); return { release, absolutePath }; } async function recordClientEvent(input) { const allowed = [ 'download_start', 'download_ok', 'download_fail', 'install_confirm', ]; if (!allowed.includes(input.eventType)) { throw new MobileReleaseError(400, 'Unsupported event type'); } // download_count is incremented when the authenticated download stream starts. if (input.releaseId && input.eventType === 'download_fail') { await repo.incrementCounter(input.releaseId, 'download_fail_count'); } if (input.releaseId && input.eventType === 'install_confirm') { await repo.incrementCounter(input.releaseId, 'install_confirm_count'); } await repo.insertEvent({ releaseId: input.releaseId ?? null, eventType: input.eventType, platform: 'android', channel: input.channel ?? 'production', clientVersionCode: input.versionCode ?? null, deviceIdHash: input.deviceId ? hashDeviceId(input.deviceId) : null, userId: input.userId ?? null, }); } async function getStats() { return repo.getStatsSummary('android'); } /** * Returns whether a client versionCode is allowed to call sensitive APIs. * When blocked, returns the update payload for a 426 response. */ async function evaluateClientVersionGate(versionCode) { if (versionCode == null || !Number.isFinite(versionCode)) { // Web / unknown clients are not gated by mobile version headers. return { allowed: true }; } const settings = await repo.getSettings(); const mandatory = await repo.findHighestMandatoryPublished('android', 'production'); const latest = await repo.findLatestPublished('android', 'production'); const belowMin = versionCode < settings.minSupportedVersionCode; const behindMandatory = !!mandatory && mandatory.versionCode > versionCode; if (!belowMin && !behindMandatory) return { allowed: true }; const target = mandatory && mandatory.versionCode > versionCode ? mandatory : latest; if (!target) { return { allowed: false, update: { updateAvailable: false, blocked: true, policy: 'mandatory', versionName: null, versionCode: null, whatsNew: null, bugFixes: null, fileSizeBytes: null, sha256: null, downloadUrl: null, downloadPath: null, minSupportedVersionCode: settings.minSupportedVersionCode, checkIntervalSeconds: settings.checkIntervalSeconds, publishedAt: null, packageName: settings.expectedPackageName, }, }; } const { token } = createDownloadToken(target.id); return { allowed: false, update: { updateAvailable: true, blocked: true, policy: 'mandatory', versionName: target.versionName, versionCode: target.versionCode, whatsNew: target.whatsNew, bugFixes: target.bugFixes, fileSizeBytes: target.fileSizeBytes, sha256: target.sha256, downloadUrl: publicDownloadUrl(target.id, token), downloadPath: publicDownloadPath(target.id, token), minSupportedVersionCode: settings.minSupportedVersionCode, checkIntervalSeconds: settings.checkIntervalSeconds, publishedAt: target.publishedAt?.toISOString() ?? null, packageName: target.packageName, }, }; } //# sourceMappingURL=mobileAppReleaseService.js.map