codeplay-common 4.9.6 → 4.9.9

package/files/buildCodeplay/release-sync.config.json

@@ -1,4 +1,4 @@
-{
-  "url": "https://htmlcodeplay.com/codeplay/api/v1/release/sync",
-  "token": "b_TiY0Lu7q7Yb0Kx9djVxA6ST8k4CFiwFQNxgci7AAU"
-}
+{
+  "url": "https://htmlcodeplay.com/codeplay/api/v1/release/sync",
+  "token": "b_TiY0Lu7q7Yb0Kx9djVxA6ST8k4CFiwFQNxgci7AAU"
+}

package/files/buildCodeplay/sync-admob-nextgen.js

@@ -0,0 +1,217 @@
+// AdMob packages version the folder; filenames inside it stay stable.
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+
+const PACKAGE_PATTERN = /^admob-nextgen-(\d+(?:\.\d+)*)$/;
+const REQUIRED_FILES = ['admob-emi-nextgen.js', 'app-open-state.js'];
+const SERVER = 'https://htmlcodeplay.com/code-play-plugin/';
+
+function compareVersions(a, b) {
+  const left = String(a).split('.').map(Number);
+  const right = String(b).split('.').map(Number);
+  for (let i = 0; i < Math.max(left.length, right.length); i++) {
+    const difference = (left[i] || 0) - (right[i] || 0);
+    if (difference) return difference;
+  }
+  return 0;
+}
+
+function isComplete(directory) {
+  return REQUIRED_FILES.every(file => fs.existsSync(path.join(directory, file))
+    && fs.statSync(path.join(directory, file)).isFile()
+    && fs.statSync(path.join(directory, file)).size > 0);
+}
+
+function findLatestPackage(adsDirectory) {
+  if (!fs.existsSync(adsDirectory)) return null;
+  return fs.readdirSync(adsDirectory).filter(name => PACKAGE_PATTERN.test(name)
+    && isComplete(path.join(adsDirectory, name)))
+    .sort((a, b) => compareVersions(b.match(PACKAGE_PATTERN)[1], a.match(PACKAGE_PATTERN)[1]))[0] || null;
+}
+
+function request(url, redirects = 0) {
+  return new Promise((resolve, reject) => {
+    const req = https.get(url, { timeout: 10000 }, response => {
+      if ([301, 302, 303, 307, 308].includes(response.statusCode) && response.headers.location) {
+        response.resume();
+        if (redirects >= 3) return reject(new Error('Too many AdMob download redirects.'));
+        const target = new URL(response.headers.location, url);
+        if (target.protocol !== 'https:') return reject(new Error('AdMob downloads require HTTPS.'));
+        resolve(request(target.href, redirects + 1));
+        return;
+      }
+      if (response.statusCode !== 200) {
+        response.resume();
+        reject(new Error(`AdMob download returned HTTP ${response.statusCode}.`));
+        return;
+      }
+      const chunks = [];
+      response.on('data', chunk => chunks.push(chunk));
+      response.on('error', reject);
+      response.on('end', () => resolve(Buffer.concat(chunks)));
+    });
+    req.on('timeout', () => req.destroy(new Error('AdMob download timed out.')));
+    req.on('error', reject);
+  });
+}
+
+function extractPackage(buffer, destination, packageName, AdmZip = require('adm-zip')) {
+  const zip = new AdmZip(buffer);
+  const entries = zip.getEntries();
+  const wrapped = entries.some(entry => entry.entryName === `${packageName}/admob-emi-nextgen.js`);
+  for (const entry of entries) {
+    let name = entry.entryName;
+    if (name.includes('\\') || name.startsWith('/') || name.split('/').includes('..')
+      || /^[a-z]:/i.test(name) || ((entry.header.attr >>> 16) & 0xf000) === 0xa000) {
+      throw new Error(`Unsafe AdMob ZIP entry: ${name}`);
+    }
+    if (wrapped) {
+      if (name === `${packageName}/`) continue;
+      if (!name.startsWith(`${packageName}/`)) throw new Error('Mixed AdMob ZIP roots.');
+      name = name.slice(packageName.length + 1);
+    }
+    if (!name) continue;
+    const target = path.resolve(destination, name);
+    if (!target.startsWith(path.resolve(destination) + path.sep)) throw new Error('Invalid AdMob ZIP path.');
+    if (entry.isDirectory) fs.mkdirSync(target, { recursive: true });
+    else {
+      fs.mkdirSync(path.dirname(target), { recursive: true });
+      fs.writeFileSync(target, entry.getData());
+    }
+  }
+  if (!isComplete(destination)) throw new Error('AdMob ZIP must contain the controller and app-open-state.js.');
+}
+
+function sourceFiles(directory) {
+  if (!fs.existsSync(directory)) return [];
+  return fs.readdirSync(directory, { withFileTypes: true }).flatMap(entry => {
+    if (['node_modules', '.git', 'android', 'ios', 'www', 'agent-temp'].includes(entry.name)) return [];
+    const fullPath = path.join(directory, entry.name);
+    if (entry.isDirectory()) return sourceFiles(fullPath);
+    return entry.isFile() && /\.(?:js|mjs|cjs|ts|f7|vue|jsx|tsx)$/.test(entry.name) ? [fullPath] : [];
+  });
+}
+
+function syncImports(projectRoot, packageName) {
+  const adsDirectory = path.join(projectRoot, 'src', 'js', 'Ads');
+  const targetDirectory = path.join(adsDirectory, packageName);
+  if (!isComplete(targetDirectory)) throw new Error('Cannot migrate imports to an incomplete AdMob package.');
+  const files = sourceFiles(path.join(projectRoot, 'src'));
+  for (const name of ['vite.config.js', 'vite.config.mjs', 'vite.config.ts']) {
+    const file = path.join(projectRoot, name);
+    if (fs.existsSync(file)) files.push(file);
+  }
+  const updates = [];
+  for (const file of files) {
+    const original = fs.readFileSync(file, 'utf8');
+    const next = original.replace(/(['"`])([^'"`\r\n]+)\1/g, (match, quote, specifier) => {
+      if (!/admob-(?:emi-nextgen|app-open-state|nextgen)-/.test(specifier)) return match;
+      if (specifier.includes('${')) throw new Error(`Computed AdMob import needs migration before cleanup: ${file}`);
+      const suffixIndex = specifier.search(/[?#]/);
+      const suffix = suffixIndex < 0 ? '' : specifier.slice(suffixIndex);
+      specifier = suffixIndex < 0 ? specifier : specifier.slice(0, suffixIndex);
+      let resolved;
+      if (specifier.startsWith('@/')) resolved = path.resolve(projectRoot, 'src', specifier.slice(2));
+      else if (specifier.startsWith('./') || specifier.startsWith('../')) resolved = path.resolve(path.dirname(file), specifier);
+      else return match;
+      const relative = path.relative(adsDirectory, resolved).split(path.sep).join('/');
+      let name;
+      if (/^admob-emi-nextgen-\d+(?:\.\d+)*\.js$/.test(relative)) name = REQUIRED_FILES[0];
+      else if (/^admob-app-open-state-\d+(?:\.\d+)*\.js$/.test(relative)) name = REQUIRED_FILES[1];
+      else {
+        const folderFile = relative.match(/^admob-nextgen-\d+(?:\.\d+)*\/(.+)$/);
+        if (!folderFile) return match;
+        name = folderFile[1];
+      }
+      const target = path.join(targetDirectory, name);
+      if (!fs.existsSync(target)) throw new Error(`AdMob import target missing: ${target}`);
+      let replacement = specifier.startsWith('@/')
+        ? `@/js/Ads/${packageName}/${name}`
+        : path.relative(path.dirname(file), target).split(path.sep).join('/');
+      if (!specifier.startsWith('@/') && !replacement.startsWith('.')) replacement = './' + replacement;
+      return quote + replacement + suffix + quote;
+    });
+    if (next !== original) updates.push({ file, next });
+  }
+  // Plan every replacement before writing or removing any legacy source.
+  for (const { file, next } of updates) fs.writeFileSync(file, next, 'utf8');
+  return updates.map(update => path.relative(projectRoot, update.file));
+}
+
+function syncPackageDependencies(projectRoot, packageName) {
+  const adsDirectory = path.join(projectRoot, 'src', 'js', 'Ads');
+  const controller = path.join(adsDirectory, packageName, REQUIRED_FILES[0]);
+  const iapFolders = fs.readdirSync(adsDirectory).filter(name => /^IAP-\d+(?:\.\d+)*$/.test(name)
+    && fs.existsSync(path.join(adsDirectory, name, 'firebase-analytics.js')))
+    .sort((a, b) => compareVersions(b.slice(4), a.slice(4)));
+  const original = fs.readFileSync(controller, 'utf8');
+  let next = original.replace(/(['"])\.\.?\/admob-ad-configuration-nextgen\.json\1/g,
+    (match, quote) => `${quote}../admob-ad-configuration-nextgen.json${quote}`);
+  if (iapFolders.length) next = next.replace(/(['"])\.\.?\/IAP-\d+(?:\.\d+)*\/firebase-analytics\.js\1/g,
+    (match, quote) => `${quote}../${iapFolders[0]}/firebase-analytics.js${quote}`);
+  if (next !== original) fs.writeFileSync(controller, next, 'utf8');
+}
+
+async function syncAdmobNextgen(options = {}) {
+  const projectRoot = path.resolve(options.projectRoot || process.cwd());
+  const adsDirectory = path.join(projectRoot, 'src', 'js', 'Ads');
+  if (!fs.existsSync(adsDirectory)) return null;
+  const log = options.log || console.log;
+  const fetch = options.request || request;
+  let latest = findLatestPackage(adsDirectory);
+  let versions = options.versions;
+  if (versions === undefined) {
+    try { versions = JSON.parse((await fetch(SERVER + 'versions.json')).toString('utf8')); }
+    catch (error) { log(`AdMob: server unavailable; retaining the installed package. ${error.message}`); }
+  }
+  // New manifests use admob-nextgen. Accept the previous key only at folder versions >= 4.0.
+  const advertisedVersion = String(versions?.['admob-nextgen'] || versions?.['admob-emi-nextgen'] || '');
+  // Match versions.json's minimum-folder rule while older live manifests still advertise a JS release.
+  const remoteVersion = /^\d+(?:\.\d+)*$/.test(advertisedVersion) && compareVersions(advertisedVersion, '4.0') >= 0
+    ? advertisedVersion : '4.0';
+  const candidates = [];
+  if (/^\d+(?:\.\d+)*$/.test(remoteVersion) && compareVersions(remoteVersion, '4.0') >= 0) {
+    candidates.push({ version: remoteVersion });
+  }
+  for (const candidate of candidates) {
+    if (latest && compareVersions(latest.match(PACKAGE_PATTERN)[1], candidate.version) >= 0) break;
+    const name = `admob-nextgen-${candidate.version}`;
+    const temporaryRoot = path.join(projectRoot, 'agent-temp', 'admob-package-sync');
+    fs.mkdirSync(temporaryRoot, { recursive: true });
+    const staging = fs.mkdtempSync(path.join(temporaryRoot, 'package-'));
+    try {
+      const buffer = await fetch(SERVER + name + '.zip');
+      extractPackage(buffer, staging, name, options.AdmZip);
+      const destination = path.join(adsDirectory, name);
+      if (fs.existsSync(destination)) throw new Error(`Incomplete AdMob package already exists: ${destination}`);
+      fs.renameSync(staging, destination);
+      latest = name;
+      log(`AdMob: installed ${name}.`);
+    } catch (error) {
+      log(`AdMob: could not install ${name}: ${error.message}`);
+    } finally {
+      fs.rmSync(staging, { recursive: true, force: true });
+    }
+  }
+  if (!latest) throw new Error('No complete AdMob folder package is available. Check admob-nextgen in the live versions.json and its ZIP on htmlcodeplay.com; existing files were preserved.');
+  syncPackageDependencies(projectRoot, latest);
+  const changed = syncImports(projectRoot, latest);
+  // Remove only this plugin's superseded files after the new imports are in place.
+  for (const entry of fs.readdirSync(adsDirectory, { withFileTypes: true })) {
+    if (entry.isFile() && /^admob-(?:emi-nextgen|app-open-state)-\d+(?:\.\d+)*\.js$/.test(entry.name)) {
+      fs.unlinkSync(path.join(adsDirectory, entry.name));
+    } else if (entry.isDirectory() && PACKAGE_PATTERN.test(entry.name) && entry.name !== latest) {
+      fs.rmSync(path.join(adsDirectory, entry.name), { recursive: true });
+    }
+  }
+  log(`AdMob: ${latest} ready; migrated ${changed.length} file(s).`);
+  return latest;
+}
+
+module.exports = { syncAdmobNextgen, syncImports, findLatestPackage, compareVersions, extractPackage };
+
+if (require.main === module) syncAdmobNextgen().catch(error => {
+  console.error(error.message);
+  process.exitCode = 1;
+});

package/files/buildCodeplay/versions.json

@@ -3,7 +3,7 @@
 {"name":"backbutton","pattern":"backbutton-(\\d+\\.\\d+)\\.js$","minVersion":"2.1","baseDir":"js","mandatoryUpdate":true},
 {"name":"common-js","pattern":"common-(\\d+\\.\\d+)(?:-beta-(\\d+))?\\.js$","minVersion":"6.7","baseDir":"js","mandatoryUpdate":true},
 
-{"name":"admob-emi-nextgen","pattern":"Ads[\\\\/]admob-emi-nextgen-(\\d+\\.\\d+)\\.js$","minVersion":"2.5","baseDir":"js","mandatoryUpdate":true},
+{"name":"admob-nextgen","pattern":"admob-nextgen-(\\d+(?:\\.\\d+)*)$","minVersion":"4.0","baseDir":"js/Ads","mandatoryUpdate":true,"isFolder":true},
 {"name":"video-player","pattern":"video-player-(\\d+\\.\\d+)\\.js$","minVersion":"1.6","baseDir":"js","mandatoryUpdate":true},
 {"name":"image-cropper","pattern":"image-cropper-(\\d+\\.\\d+)\\.js$","minVersion":"1.1","baseDir":"js","mandatoryUpdate":true},
 {"name":"beautify","pattern":"beautify-(\\d+\\.\\d+)\\.js$","minVersion":"1.1","baseDir":"js","mandatoryUpdate":true},

package/files/finalrelease

@@ -103,24 +103,24 @@ function checkProductionAdmobAlias() {
     const viteConfigContent = stripJavaScriptComments(readFileSync(viteConfigPath, 'utf8'));
     const aliasPattern = /(['"])@admob\1\s*:\s*path\.resolve\(\s*__dirname\s*,\s*(['"])([^'"\r\n]+)\2\s*\)/g;
     const activeAliases = [...viteConfigContent.matchAll(aliasPattern)].map(match => match[3]);
-    const productionAliasPattern = /^\.\/src\/js\/Ads\/admob-emi-nextgen-\d+(?:\.\d+)+\.js$/;
+    const productionAliasPattern = /^\.\/src\/js\/Ads\/(?:admob-nextgen-\d+(?:\.\d+)+\/admob-emi-nextgen|admob-emi-nextgen-\d+(?:\.\d+)+)\.js$/;
 
     if (activeAliases.length === 0) {
         console.error('❌ FINAL RELEASE BLOCKED: The production @admob alias is commented out or missing in the Vite config.');
-        console.error("   Enable: '@admob': path.resolve(__dirname, './src/js/Ads/admob-emi-nextgen-x.x.js')");
+        console.error("   Enable: '@admob': path.resolve(__dirname, './src/js/Ads/admob-nextgen-x.x/admob-emi-nextgen.js')");
         process.exit(1);
     }
 
     if (activeAliases.length > 1) {
         console.error('❌ FINAL RELEASE BLOCKED: Multiple active @admob aliases were found in the Vite config.');
-        console.error('   Keep exactly one active production admob-emi-nextgen-x.x.js alias.');
+        console.error('   Keep exactly one active production @admob alias.');
         process.exit(1);
     }
 
     const activeAlias = activeAliases[0];
     if (!productionAliasPattern.test(activeAlias)) {
         console.error(`❌ FINAL RELEASE BLOCKED: @admob currently points to '${activeAlias}'.`);
-        console.error("   It must point to './src/js/Ads/admob-emi-nextgen-x.x.js', not a test AdMob file.");
+        console.error("   It must point to './src/js/Ads/admob-nextgen-x.x/admob-emi-nextgen.js', not a test AdMob file.");
         process.exit(1);
     }
 
@@ -464,19 +464,13 @@ const checkIsTestingInAdmob=()=>{
 const checkIsAdsDisableByReturnStatement=()=>{
     
     
-    const adsFolder = join('src', 'js', 'Ads');
-    const filePattern = /^admob-emi-nextgen-(\d+\.)+\d+\.js$/;
-    
-    // Step 1: Find the admob file
-    const files = readdirSync(adsFolder);
-    const admobFile = files.find(f => filePattern.test(f));
-    
-    if (!admobFile) {
-      console.log('❌ No Admob nextgen file found.');
-      process.exit(1);
-    }
-    
-    const filePath = join(adsFolder, admobFile);
+    // Inspect the controller selected by the validated production alias.
+    const viteFile = ['vite.config.mjs', 'vite.config.js']
+      .map(file => resolve(__dirname, file)).find(file => existsSync(file));
+    const config = stripJavaScriptComments(readFileSync(viteFile, 'utf8'));
+    const alias = config.match(/(['"])@admob\1\s*:\s*path\.resolve\(\s*__dirname\s*,\s*(['"])([^'"\r\n]+)\2\s*\)/);
+    const filePath = resolve(__dirname, alias[3]);
+    const admobFile = alias[3];
     const content = readFileSync(filePath, 'utf-8');
     
     // Step 2: Extract the adsOnDeviceReady function body

package/files/generate-ai-promo-video.js

@@ -86,8 +86,8 @@ const analysisFrameDirectory = path.join(temporaryDirectory, 'ai-analysis');
 const endCardBannerPath = path.join(outputVideoDirectory, `${appFilePrefix}-ai-end-card-banner.png`);
 const promoCopySchemaPath = path.join(temporaryDirectory, 'promo-copy-schema.json');
 const promoCopyResultPath = path.join(temporaryDirectory, 'promo-copy-result.json');
-const ffmpegFallbackDirectory = String(process.env.FFMPEG_BIN || '').trim()
-  || path.join(projectDirectory, 'tools', 'ffmpeg');
+const ffmpegFallbackDirectory = String(process.env.FFMPEG_BIN || '').trim()
+  || path.join(projectDirectory, 'tools', 'ffmpeg');
 const minimumSceneCount = 7;
 const minimumSourceDuration = 12;
 let expectedDuration = 34;
@@ -209,15 +209,15 @@ async function ensureEndCardBanner() {
       + '- Keep all logos and badge text sharp, correctly proportioned, and completely visible.\n'
       + '- Match the background colors and visual style to the actual app icon.\n'
       + '- Create a polished, professional background related to the app’s purpose.\n'
-      + '- Keep the background subtle so it does not compete with the icon, title, feature text, or download badges.\n'
+      + '- Keep the background subtle so it does not compete with the icon, title, feature text, or download badges.\n'
       + '- Use a balanced landscape composition:\n'
       + '  - Large actual app icon on the left.\n'
       + '  - App Store badge followed by Google Play badge on the right.\n'
       + '  - Maintain comfortable margins and clear space around every element.\n'
-      + '- Add the application title prominently.\n'
-      + '- Add concise promotional text describing the application’s actual features, presenting each feature one by one.\n'
-      + '- Keep the title and feature text sharp, readable, accurate, and visually balanced with the icon and download badges.\n'
-      + '- Do not invent unsupported features or add unrelated marketing text.\n'
+      + '- Add the application title prominently.\n'
+      + '- Add concise promotional text describing the application’s actual features, presenting each feature one by one.\n'
+      + '- Keep the title and feature text sharp, readable, accurate, and visually balanced with the icon and download badges.\n'
+      + '- Do not invent unsupported features or add unrelated marketing text.\n'
       + '- Do not add watermarks, fake UI, generated symbols, or unrelated decorations.\n'
       + '- Rounded corners and a subtle shadow may be applied around the app icon, but its internal artwork must remain unchanged.\n'
       + '- Use image generation only for the background.\n'
@@ -467,12 +467,12 @@ function commandExists(command) {
   return !result.error && result.status === 0;
 }
 
-function getExecutable(command) {
-  const executableName = process.platform === 'win32' ? `${command}.exe` : command;
-  const fallbackPath = path.join(ffmpegFallbackDirectory, executableName);
-  if (fs.existsSync(fallbackPath)) return fallbackPath;
-  return commandExists(command) ? command : '';
-}
+function getExecutable(command) {
+  const executableName = process.platform === 'win32' ? `${command}.exe` : command;
+  const fallbackPath = path.join(ffmpegFallbackDirectory, executableName);
+  if (fs.existsSync(fallbackPath)) return fallbackPath;
+  return commandExists(command) ? command : '';
+}
 
 function detectRedundantStaticRanges(ffmpegCommand, inputPath, sourceDuration) {
   const minimumStaticDuration = Math.max(2, Math.min(4, sourceDuration / 60));
@@ -640,7 +640,7 @@ function resolvePromoLayout(requestedLayout) {
 }
 
 function getPythonExecutable() {
-  for (const candidate of ['py', 'python', 'python3']) {
+  for (const candidate of ['py', 'python', 'python3']) {
     const result = spawnSync(candidate, ['-m', 'edge_tts', '--version'], {
       encoding: 'utf8',
       windowsHide: true,
@@ -915,7 +915,7 @@ Rules:
 - footer_keywords must contain exactly 3 distinct, natural app-search phrases, each 2-24 characters.
 - Generate a YouTube upload title and description from the same verified features.
 - YouTube title: 40-100 characters, include ${JSON.stringify(appName)} and one strong natural search phrase, without clickbait.
-- YouTube description: 350-1500 characters with readable paragraphs. Put the clearest app summary and primary search phrase in the opening two lines, explain the demonstrated features, add a simple call to action, then insert a newline and finish with exactly 3 relevant hashtags on that separate final line. The hashtags must not be appended to the preceding paragraph.
+- YouTube description: 350-1500 characters with readable paragraphs. Put the clearest app summary and primary search phrase in the opening two lines, explain the demonstrated features, add a simple call to action, then insert a newline and finish with exactly 3 relevant hashtags on that separate final line. The hashtags must not be appended to the preceding paragraph.
 - Do not add download links or URLs; the script will append the verified Google Play URL built from the configured package ID. Do not add chapter timestamps or unsupported availability claims.
 - Keep YouTube text natural and useful; do not repeat keywords unnaturally.
 - Avoid prices, ratings, awards, competitor names, unsupported superlatives, and words such as best, guaranteed, or free.
@@ -1025,14 +1025,14 @@ function validatePromoCopy(value) {
     throw new Error(`The final scene must mention the app name ${JSON.stringify(appName)}.`);
   }
 
-  const youtubeTitle = cleanGeneratedString(value.youtube.title);
-  let youtubeDescription = cleanGeneratedDescription(value.youtube.description);
-  const trailingHashtagGroup = youtubeDescription.match(
-    /(?:^|\s)(#[\p{L}\p{N}_]+\s+#[\p{L}\p{N}_]+\s+#[\p{L}\p{N}_]+)\s*$/u,
-  );
-  if (trailingHashtagGroup) {
-    youtubeDescription = `${youtubeDescription.slice(0, trailingHashtagGroup.index).trimEnd()}\n${trailingHashtagGroup[1]}`;
-  }
+  const youtubeTitle = cleanGeneratedString(value.youtube.title);
+  let youtubeDescription = cleanGeneratedDescription(value.youtube.description);
+  const trailingHashtagGroup = youtubeDescription.match(
+    /(?:^|\s)(#[\p{L}\p{N}_]+\s+#[\p{L}\p{N}_]+\s+#[\p{L}\p{N}_]+)\s*$/u,
+  );
+  if (trailingHashtagGroup) {
+    youtubeDescription = `${youtubeDescription.slice(0, trailingHashtagGroup.index).trimEnd()}\n${trailingHashtagGroup[1]}`;
+  }
   if (youtubeTitle.length < 40 || youtubeTitle.length > 100) {
     throw new Error('YouTube title must be 40-100 characters.');
   }